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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
u475675023
|
p03524
|
python
|
s826834956
|
s628276491
| 24
| 19
| 4,084
| 3,188
|
Accepted
|
Accepted
| 20.83
|
s=eval(input())
a=s.count('a')
b=s.count('b')
c=s.count('c')
if len(set(list(s)))==1 and len(s)>1:
print('NO')
elif len(set(list(s)))==2 and len(s)>2:
print('NO')
elif abs(a-b)<=1 and abs(b-c)<=1 and abs(c-a)<=1:
print('YES')
else:
print('NO')
|
s=eval(input())
a=s.count('a')
b=s.count('b')
c=s.count('c')
if abs(a-b)<=1 and abs(b-c)<=1 and abs(c-a)<=1:
print('YES')
else:
print('NO')
| 12
| 8
| 256
| 144
|
s = eval(input())
a = s.count("a")
b = s.count("b")
c = s.count("c")
if len(set(list(s))) == 1 and len(s) > 1:
print("NO")
elif len(set(list(s))) == 2 and len(s) > 2:
print("NO")
elif abs(a - b) <= 1 and abs(b - c) <= 1 and abs(c - a) <= 1:
print("YES")
else:
print("NO")
|
s = eval(input())
a = s.count("a")
b = s.count("b")
c = s.count("c")
if abs(a - b) <= 1 and abs(b - c) <= 1 and abs(c - a) <= 1:
print("YES")
else:
print("NO")
| false
| 33.333333
|
[
"-if len(set(list(s))) == 1 and len(s) > 1:",
"- print(\"NO\")",
"-elif len(set(list(s))) == 2 and len(s) > 2:",
"- print(\"NO\")",
"-elif abs(a - b) <= 1 and abs(b - c) <= 1 and abs(c - a) <= 1:",
"+if abs(a - b) <= 1 and abs(b - c) <= 1 and abs(c - a) <= 1:"
] | false
| 0.114618
| 0.03421
| 3.350398
|
[
"s826834956",
"s628276491"
] |
u133936772
|
p03503
|
python
|
s093466136
|
s479516885
| 211
| 59
| 3,188
| 3,188
|
Accepted
|
Accepted
| 72.04
|
f=lambda:[list(map(int,input().split())) for _ in range(n)]
n=int(eval(input()))
llf,llp=f(),f()
a=-10**9
import itertools as it
for t in it.product([0,1],repeat=10):
if sum(t):
lc=[sum(t[i]*lf[i] for i in range(10)) for lf in llf]
a=max(a,sum(llp[i][lc[i]] for i in range(n)))
print(a)
|
I=input;R=range;n=int(I())
lf=[int(I()[::2],2) for _ in R(n)]
lp=[list(map(int,I().split())) for _ in R(n)]
print((max(sum(p[bin(i&f).count('1')] for f,p in zip(lf,lp)) for i in R(1,1024))))
| 10
| 4
| 299
| 191
|
f = lambda: [list(map(int, input().split())) for _ in range(n)]
n = int(eval(input()))
llf, llp = f(), f()
a = -(10**9)
import itertools as it
for t in it.product([0, 1], repeat=10):
if sum(t):
lc = [sum(t[i] * lf[i] for i in range(10)) for lf in llf]
a = max(a, sum(llp[i][lc[i]] for i in range(n)))
print(a)
|
I = input
R = range
n = int(I())
lf = [int(I()[::2], 2) for _ in R(n)]
lp = [list(map(int, I().split())) for _ in R(n)]
print((max(sum(p[bin(i & f).count("1")] for f, p in zip(lf, lp)) for i in R(1, 1024))))
| false
| 60
|
[
"-f = lambda: [list(map(int, input().split())) for _ in range(n)]",
"-n = int(eval(input()))",
"-llf, llp = f(), f()",
"-a = -(10**9)",
"-import itertools as it",
"-",
"-for t in it.product([0, 1], repeat=10):",
"- if sum(t):",
"- lc = [sum(t[i] * lf[i] for i in range(10)) for lf in llf]",
"- a = max(a, sum(llp[i][lc[i]] for i in range(n)))",
"-print(a)",
"+I = input",
"+R = range",
"+n = int(I())",
"+lf = [int(I()[::2], 2) for _ in R(n)]",
"+lp = [list(map(int, I().split())) for _ in R(n)]",
"+print((max(sum(p[bin(i & f).count(\"1\")] for f, p in zip(lf, lp)) for i in R(1, 1024))))"
] | false
| 0.062973
| 0.038158
| 1.650315
|
[
"s093466136",
"s479516885"
] |
u970269944
|
p00462
|
python
|
s676019758
|
s505429009
| 370
| 340
| 16,380
| 15,572
|
Accepted
|
Accepted
| 8.11
|
mapping = {}
def find(l, e, start, end):
global mapping
if e in mapping:
return mapping[e]
mid = (start+end)//2
if (l[mid] == e):
mapping[e] = (e, e)
return mapping[e]
elif (l[mid] > e):
if (l[mid-1] < e):
mapping[e] = (l[mid-1], l[mid])
return mapping[e]
return find(l, e, start, mid)
elif (l[mid] < e):
if (l[mid+1] > e):
mapping[e] = (l[mid], l[mid+1])
return mapping[e]
return find(l, e, mid, end)
def print_sum(input):
global mapping
mapping = {}
d, n, m = input[0], input[1], input[2]
S, K = input[3:3+n-1], input[3+n-1:]
S = sorted(S)
S = [S[-1]-d, 0] + S + [d]
sum = 0
for k in K:
low, high = find(S, k, 0, len(S))
sum += min(k-low, high-k)
print(sum)
while (True):
d = int(input())
if d == 0: break
n, m = int(input()), int(input())
input = [d, n, m]
for i in range(n-1+m):
next_int = int(input())
input.append(next_int)
print_sum(input)
|
def find(l, e, start, end):
mid = (start+end)//2
if (l[mid] == e):
return (e, e)
elif (l[mid] > e):
if (l[mid-1] < e):
return (l[mid-1], l[mid])
return find(l, e, start, mid)
elif (l[mid] < e):
if (l[mid+1] > e):
return (l[mid], l[mid+1])
return find(l, e, mid, end)
def print_sum(input):
d, n, m = input[0], input[1], input[2]
S, K = input[3:3+n-1], input[3+n-1:]
S = sorted(S)
S = [S[-1]-d, 0] + S + [d]
sum = 0
for k in K:
low, high = find(S, k, 0, len(S))
sum += min(k-low, high-k)
print(sum)
while (True):
d = int(input())
if d == 0: break
n, m = int(input()), int(input())
input = [d, n, m]
for i in range(n-1+m):
next_int = int(input())
input.append(next_int)
print_sum(input)
| 42
| 33
| 960
| 773
|
mapping = {}
def find(l, e, start, end):
global mapping
if e in mapping:
return mapping[e]
mid = (start + end) // 2
if l[mid] == e:
mapping[e] = (e, e)
return mapping[e]
elif l[mid] > e:
if l[mid - 1] < e:
mapping[e] = (l[mid - 1], l[mid])
return mapping[e]
return find(l, e, start, mid)
elif l[mid] < e:
if l[mid + 1] > e:
mapping[e] = (l[mid], l[mid + 1])
return mapping[e]
return find(l, e, mid, end)
def print_sum(input):
global mapping
mapping = {}
d, n, m = input[0], input[1], input[2]
S, K = input[3 : 3 + n - 1], input[3 + n - 1 :]
S = sorted(S)
S = [S[-1] - d, 0] + S + [d]
sum = 0
for k in K:
low, high = find(S, k, 0, len(S))
sum += min(k - low, high - k)
print(sum)
while True:
d = int(input())
if d == 0:
break
n, m = int(input()), int(input())
input = [d, n, m]
for i in range(n - 1 + m):
next_int = int(input())
input.append(next_int)
print_sum(input)
|
def find(l, e, start, end):
mid = (start + end) // 2
if l[mid] == e:
return (e, e)
elif l[mid] > e:
if l[mid - 1] < e:
return (l[mid - 1], l[mid])
return find(l, e, start, mid)
elif l[mid] < e:
if l[mid + 1] > e:
return (l[mid], l[mid + 1])
return find(l, e, mid, end)
def print_sum(input):
d, n, m = input[0], input[1], input[2]
S, K = input[3 : 3 + n - 1], input[3 + n - 1 :]
S = sorted(S)
S = [S[-1] - d, 0] + S + [d]
sum = 0
for k in K:
low, high = find(S, k, 0, len(S))
sum += min(k - low, high - k)
print(sum)
while True:
d = int(input())
if d == 0:
break
n, m = int(input()), int(input())
input = [d, n, m]
for i in range(n - 1 + m):
next_int = int(input())
input.append(next_int)
print_sum(input)
| false
| 21.428571
|
[
"-mapping = {}",
"-",
"-",
"- global mapping",
"- if e in mapping:",
"- return mapping[e]",
"- mapping[e] = (e, e)",
"- return mapping[e]",
"+ return (e, e)",
"- mapping[e] = (l[mid - 1], l[mid])",
"- return mapping[e]",
"+ return (l[mid - 1], l[mid])",
"- mapping[e] = (l[mid], l[mid + 1])",
"- return mapping[e]",
"+ return (l[mid], l[mid + 1])",
"- global mapping",
"- mapping = {}"
] | false
| 0.112596
| 0.104598
| 1.076466
|
[
"s676019758",
"s505429009"
] |
u281610856
|
p02723
|
python
|
s028879304
|
s721591275
| 41
| 18
| 3,060
| 2,940
|
Accepted
|
Accepted
| 56.1
|
s = eval(input())
if s[2] == s[3] and s[4] == s[5]:
print('Yes')
else:
print('No')
|
import sys
input = sys.stdin.readline
def main():
s = eval(input())
if s[2] == s[3] and s[4] == s[5]:
print("Yes")
else:
print("No")
if __name__ == '__main__':
main()
| 5
| 13
| 88
| 207
|
s = eval(input())
if s[2] == s[3] and s[4] == s[5]:
print("Yes")
else:
print("No")
|
import sys
input = sys.stdin.readline
def main():
s = eval(input())
if s[2] == s[3] and s[4] == s[5]:
print("Yes")
else:
print("No")
if __name__ == "__main__":
main()
| false
| 61.538462
|
[
"-s = eval(input())",
"-if s[2] == s[3] and s[4] == s[5]:",
"- print(\"Yes\")",
"-else:",
"- print(\"No\")",
"+import sys",
"+",
"+input = sys.stdin.readline",
"+",
"+",
"+def main():",
"+ s = eval(input())",
"+ if s[2] == s[3] and s[4] == s[5]:",
"+ print(\"Yes\")",
"+ else:",
"+ print(\"No\")",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false
| 0.040285
| 0.076033
| 0.529831
|
[
"s028879304",
"s721591275"
] |
u644907318
|
p03229
|
python
|
s258527446
|
s157885009
| 646
| 203
| 60,248
| 95,044
|
Accepted
|
Accepted
| 68.58
|
from collections import deque
N = int(eval(input()))
A = deque(sorted([int(eval(input())) for _ in range(N)]))
B = deque([])
B.append(A.popleft())
cnt = 0
while A:
a0 = A[0]
a1 = A[-1]
b0 = B[0]
b1 = B[-1]
c00 = abs(a0-b0)
c01 = abs(a0-b1)
c10 = abs(a1-b0)
c11 = abs(a1-b1)
cmax = max(c00,c01,c10,c11)
if cmax == c00:
B.appendleft(A.popleft())
elif cmax == c01:
B.append(A.popleft())
elif cmax == c10:
B.appendleft(A.pop())
else:
B.append(A.pop())
cnt += cmax
print(cnt)
|
N = int(eval(input()))
A = sorted([int(eval(input())) for _ in range(N)])
if N%2==0:
B = A[:N//2]
C = A[N//2:]
C = C[::-1]
D1 = []
D2 = []
for i in range(N//2-1):
D1.append(B[i])
D1.append(C[i])
D2.append(C[i])
D2.append(B[i])
D1.append(B[-1])
D1.insert(0,C[-1])
D2.append(C[-1])
D2.insert(0,B[-1])
cnt1 = 0
cnt2 = 0
for i in range(1,N):
cnt1 += abs(D1[i]-D1[i-1])
cnt2 += abs(D2[i]-D2[i-1])
print((max(cnt1,cnt2)))
else:
B = A[:N//2]
C = A[N//2+1:]
C = C[::-1]
D1 = []
D2 = []
for i in range(N//2):
D1.append(B[i])
D1.append(C[i])
D2.append(C[i])
D2.append(B[i])
cnt1 = 0
cnt2 = 0
for i in range(1,N-1):
cnt1 += abs(D1[i]-D1[i-1])
cnt2 += abs(D2[i]-D2[i-1])
cnt1 += max(A[N//2]-D1[0],D1[-1]-A[N//2])
cnt2 += max(D2[0]-A[N//2],A[N//2]-D2[-1])
print((max(cnt1,cnt2)))
| 26
| 42
| 571
| 991
|
from collections import deque
N = int(eval(input()))
A = deque(sorted([int(eval(input())) for _ in range(N)]))
B = deque([])
B.append(A.popleft())
cnt = 0
while A:
a0 = A[0]
a1 = A[-1]
b0 = B[0]
b1 = B[-1]
c00 = abs(a0 - b0)
c01 = abs(a0 - b1)
c10 = abs(a1 - b0)
c11 = abs(a1 - b1)
cmax = max(c00, c01, c10, c11)
if cmax == c00:
B.appendleft(A.popleft())
elif cmax == c01:
B.append(A.popleft())
elif cmax == c10:
B.appendleft(A.pop())
else:
B.append(A.pop())
cnt += cmax
print(cnt)
|
N = int(eval(input()))
A = sorted([int(eval(input())) for _ in range(N)])
if N % 2 == 0:
B = A[: N // 2]
C = A[N // 2 :]
C = C[::-1]
D1 = []
D2 = []
for i in range(N // 2 - 1):
D1.append(B[i])
D1.append(C[i])
D2.append(C[i])
D2.append(B[i])
D1.append(B[-1])
D1.insert(0, C[-1])
D2.append(C[-1])
D2.insert(0, B[-1])
cnt1 = 0
cnt2 = 0
for i in range(1, N):
cnt1 += abs(D1[i] - D1[i - 1])
cnt2 += abs(D2[i] - D2[i - 1])
print((max(cnt1, cnt2)))
else:
B = A[: N // 2]
C = A[N // 2 + 1 :]
C = C[::-1]
D1 = []
D2 = []
for i in range(N // 2):
D1.append(B[i])
D1.append(C[i])
D2.append(C[i])
D2.append(B[i])
cnt1 = 0
cnt2 = 0
for i in range(1, N - 1):
cnt1 += abs(D1[i] - D1[i - 1])
cnt2 += abs(D2[i] - D2[i - 1])
cnt1 += max(A[N // 2] - D1[0], D1[-1] - A[N // 2])
cnt2 += max(D2[0] - A[N // 2], A[N // 2] - D2[-1])
print((max(cnt1, cnt2)))
| false
| 38.095238
|
[
"-from collections import deque",
"-",
"-A = deque(sorted([int(eval(input())) for _ in range(N)]))",
"-B = deque([])",
"-B.append(A.popleft())",
"-cnt = 0",
"-while A:",
"- a0 = A[0]",
"- a1 = A[-1]",
"- b0 = B[0]",
"- b1 = B[-1]",
"- c00 = abs(a0 - b0)",
"- c01 = abs(a0 - b1)",
"- c10 = abs(a1 - b0)",
"- c11 = abs(a1 - b1)",
"- cmax = max(c00, c01, c10, c11)",
"- if cmax == c00:",
"- B.appendleft(A.popleft())",
"- elif cmax == c01:",
"- B.append(A.popleft())",
"- elif cmax == c10:",
"- B.appendleft(A.pop())",
"- else:",
"- B.append(A.pop())",
"- cnt += cmax",
"-print(cnt)",
"+A = sorted([int(eval(input())) for _ in range(N)])",
"+if N % 2 == 0:",
"+ B = A[: N // 2]",
"+ C = A[N // 2 :]",
"+ C = C[::-1]",
"+ D1 = []",
"+ D2 = []",
"+ for i in range(N // 2 - 1):",
"+ D1.append(B[i])",
"+ D1.append(C[i])",
"+ D2.append(C[i])",
"+ D2.append(B[i])",
"+ D1.append(B[-1])",
"+ D1.insert(0, C[-1])",
"+ D2.append(C[-1])",
"+ D2.insert(0, B[-1])",
"+ cnt1 = 0",
"+ cnt2 = 0",
"+ for i in range(1, N):",
"+ cnt1 += abs(D1[i] - D1[i - 1])",
"+ cnt2 += abs(D2[i] - D2[i - 1])",
"+ print((max(cnt1, cnt2)))",
"+else:",
"+ B = A[: N // 2]",
"+ C = A[N // 2 + 1 :]",
"+ C = C[::-1]",
"+ D1 = []",
"+ D2 = []",
"+ for i in range(N // 2):",
"+ D1.append(B[i])",
"+ D1.append(C[i])",
"+ D2.append(C[i])",
"+ D2.append(B[i])",
"+ cnt1 = 0",
"+ cnt2 = 0",
"+ for i in range(1, N - 1):",
"+ cnt1 += abs(D1[i] - D1[i - 1])",
"+ cnt2 += abs(D2[i] - D2[i - 1])",
"+ cnt1 += max(A[N // 2] - D1[0], D1[-1] - A[N // 2])",
"+ cnt2 += max(D2[0] - A[N // 2], A[N // 2] - D2[-1])",
"+ print((max(cnt1, cnt2)))"
] | false
| 0.040755
| 0.076485
| 0.532855
|
[
"s258527446",
"s157885009"
] |
u748241164
|
p03835
|
python
|
s692697699
|
s351549572
| 1,468
| 1,042
| 2,940
| 9,160
|
Accepted
|
Accepted
| 29.02
|
K, S = list(map(int, input().split()))
count= 0
for i in range(K+1):# X
for j in range(K+1):#Y
Z = S - i - j
if 0 <= Z <= K:
count += 1
#print(i,j,Z)
print(count)
|
K, S = list(map(int, input().split()))
ans = 0
for i in range(K + 1):
for j in range(K + 1):
#print(i, j)
if 0 <= S - i - j <= K:
ans += 1
print(ans)
| 11
| 10
| 190
| 182
|
K, S = list(map(int, input().split()))
count = 0
for i in range(K + 1): # X
for j in range(K + 1): # Y
Z = S - i - j
if 0 <= Z <= K:
count += 1
# print(i,j,Z)
print(count)
|
K, S = list(map(int, input().split()))
ans = 0
for i in range(K + 1):
for j in range(K + 1):
# print(i, j)
if 0 <= S - i - j <= K:
ans += 1
print(ans)
| false
| 9.090909
|
[
"-count = 0",
"-for i in range(K + 1): # X",
"- for j in range(K + 1): # Y",
"- Z = S - i - j",
"- if 0 <= Z <= K:",
"- count += 1",
"- # print(i,j,Z)",
"-print(count)",
"+ans = 0",
"+for i in range(K + 1):",
"+ for j in range(K + 1):",
"+ # print(i, j)",
"+ if 0 <= S - i - j <= K:",
"+ ans += 1",
"+print(ans)"
] | false
| 0.055113
| 0.140604
| 0.391972
|
[
"s692697699",
"s351549572"
] |
u935558307
|
p02990
|
python
|
s848538600
|
s425604097
| 480
| 275
| 79,856
| 167,936
|
Accepted
|
Accepted
| 42.71
|
"""
問題文は言い換えると、青いボールの連続する区間の数がi個になるような並べ方はいくつあるか。というもの
上記のような並べ方はさらに4種類に分けられる。
(1). 両端が青色になるような並べ方
(2). 両端が赤色になるような並べ方
(3). 左端が赤色、右端が青色になるような並べ方
(4). 左端が青色、右端が赤色になるような並べ方
(1)の場合：A(K個並んでいるの青ボールの隙間にi-1個の赤ボールグループをぶっこむ箇所の場合の数) × B(i-1個のグループに割り振る赤ボールの数)
Aは(k-1)個の隙間から(i-1)個の隙間を選ぶ場合の数なので、(k-1)C(i-1)で計算できる。Bは各グループに最低1個は赤色のボールを割り当てるとして残りN-K-(i-1)をどう分けるか、の場合の数なので、(N-K-(i-1)+(i-2))C(i-2)で計算できる。
(2)の場合：A(K個並んでいるの青ボールの隙間にi-1個の赤ボールグループをぶっこむ箇所の場合の数) × B(i+1個のグループに割り振る赤ボールの数)
Aは(1)と同様なので省略。Bは各グループに最低1個は赤色のボールを割り当てるとして残りN-K-(i+1)をどう分けるか、の場合の数なので、(N-K-(i+1)+i)C(i)で計算できる。
(3)の場合：A(K個並んでいるの青ボールの隙間にi-1個の赤ボールグループをぶっこむ箇所の場合の数) × B(i個のグループに割り振る赤ボールの数)
Aは(1)と同様なので省略。Bは各グループに最低1個は赤色のボールを割り当てるとして残りN-K-iをどう分けるか、の場合の数なので、(N-K-i+(i-1))C(i-1)で計算できる。
(4)は(3)と同様なので省略
なお、赤のボールの数が分割するグループの数以上存在していないと行けないことに注意。
"""
def choose(n,k):
import math
return math.factorial(n)//(math.factorial(n-k)*math.factorial(k))
mod = 10**9 +7
N,K = list(map(int,input().split()))
for i in range(1,K+1):
ans = 0
A = choose(K-1,i-1)
#(1)の場合の数を求める
if N-K >= i-1:
if i-2>=0:
B = choose(N-K-(i-1)+(i-2),i-2)
ans += A*B
ans %= mod
elif N==K:
ans += 1
if N-K >= i+1:
B = choose(N-K-(i+1)+i,i)
ans += A*B
ans %= mod
if N-K >= i:
B = choose(N-K-i+(i-1),i-1)
ans += A*B*2
ans %= mod
print(ans)
|
"""
Kをi分割する場合の数＝cmb(K+i-1,i-1)
両端が赤になる場合、両端が青になる場合、左端のみ赤になる場合、右端のみ赤になる場合についてそれぞれ計算すればよい。
"""
def cmb(n, r, p):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * factinv[r] * factinv[n-r] % p
p = 10 ** 9 + 7
N = 10 ** 6 # N は必要分だけ用意する
fact = [1, 1] # fact[n] = (n! mod p)
factinv = [1, 1] # factinv[n] = ((n!)^(-1) mod p)
inv = [0, 1] # factinv 計算用
for i in range(2, N + 1):
fact.append((fact[-1] * i) % p)
inv.append((-inv[p % i] * (p // i)) % p)
factinv.append((factinv[-1] * inv[-1]) % p)
N,K = list(map(int,input().split()))
for i in range(1,K+1):
ans = 0
#Kをi分割する場合の数
divideK = cmb(K-i+i-1,i-1,p)
#両端が赤の場合の置き方
ans += divideK*cmb(N-K-(i+1)+i,i,p)%p
ans %= p
#両端が青の場合の置き方
if i > 1:
ans += divideK*cmb(N-K-(i-1)+i-2,i-2,p)%p
ans %= p
elif N-K == 0:
ans += 1
#左端のみが赤になる場合の置き方,右端のみが赤になる場合の置き方
ans += divideK*cmb(N-K-i+i-1,i-1,p)*2%p
ans %= p
print(ans)
| 52
| 39
| 1,458
| 1,016
|
"""
問題文は言い換えると、青いボールの連続する区間の数がi個になるような並べ方はいくつあるか。というもの
上記のような並べ方はさらに4種類に分けられる。
(1). 両端が青色になるような並べ方
(2). 両端が赤色になるような並べ方
(3). 左端が赤色、右端が青色になるような並べ方
(4). 左端が青色、右端が赤色になるような並べ方
(1)の場合：A(K個並んでいるの青ボールの隙間にi-1個の赤ボールグループをぶっこむ箇所の場合の数) × B(i-1個のグループに割り振る赤ボールの数)
Aは(k-1)個の隙間から(i-1)個の隙間を選ぶ場合の数なので、(k-1)C(i-1)で計算できる。Bは各グループに最低1個は赤色のボールを割り当てるとして残りN-K-(i-1)をどう分けるか、の場合の数なので、(N-K-(i-1)+(i-2))C(i-2)で計算できる。
(2)の場合：A(K個並んでいるの青ボールの隙間にi-1個の赤ボールグループをぶっこむ箇所の場合の数) × B(i+1個のグループに割り振る赤ボールの数)
Aは(1)と同様なので省略。Bは各グループに最低1個は赤色のボールを割り当てるとして残りN-K-(i+1)をどう分けるか、の場合の数なので、(N-K-(i+1)+i)C(i)で計算できる。
(3)の場合：A(K個並んでいるの青ボールの隙間にi-1個の赤ボールグループをぶっこむ箇所の場合の数) × B(i個のグループに割り振る赤ボールの数)
Aは(1)と同様なので省略。Bは各グループに最低1個は赤色のボールを割り当てるとして残りN-K-iをどう分けるか、の場合の数なので、(N-K-i+(i-1))C(i-1)で計算できる。
(4)は(3)と同様なので省略
なお、赤のボールの数が分割するグループの数以上存在していないと行けないことに注意。
"""
def choose(n, k):
import math
return math.factorial(n) // (math.factorial(n - k) * math.factorial(k))
mod = 10**9 + 7
N, K = list(map(int, input().split()))
for i in range(1, K + 1):
ans = 0
A = choose(K - 1, i - 1)
# (1)の場合の数を求める
if N - K >= i - 1:
if i - 2 >= 0:
B = choose(N - K - (i - 1) + (i - 2), i - 2)
ans += A * B
ans %= mod
elif N == K:
ans += 1
if N - K >= i + 1:
B = choose(N - K - (i + 1) + i, i)
ans += A * B
ans %= mod
if N - K >= i:
B = choose(N - K - i + (i - 1), i - 1)
ans += A * B * 2
ans %= mod
print(ans)
|
"""
Kをi分割する場合の数＝cmb(K+i-1,i-1)
両端が赤になる場合、両端が青になる場合、左端のみ赤になる場合、右端のみ赤になる場合についてそれぞれ計算すればよい。
"""
def cmb(n, r, p):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * factinv[r] * factinv[n - r] % p
p = 10**9 + 7
N = 10**6 # N は必要分だけ用意する
fact = [1, 1] # fact[n] = (n! mod p)
factinv = [1, 1] # factinv[n] = ((n!)^(-1) mod p)
inv = [0, 1] # factinv 計算用
for i in range(2, N + 1):
fact.append((fact[-1] * i) % p)
inv.append((-inv[p % i] * (p // i)) % p)
factinv.append((factinv[-1] * inv[-1]) % p)
N, K = list(map(int, input().split()))
for i in range(1, K + 1):
ans = 0
# Kをi分割する場合の数
divideK = cmb(K - i + i - 1, i - 1, p)
# 両端が赤の場合の置き方
ans += divideK * cmb(N - K - (i + 1) + i, i, p) % p
ans %= p
# 両端が青の場合の置き方
if i > 1:
ans += divideK * cmb(N - K - (i - 1) + i - 2, i - 2, p) % p
ans %= p
elif N - K == 0:
ans += 1
# 左端のみが赤になる場合の置き方,右端のみが赤になる場合の置き方
ans += divideK * cmb(N - K - i + i - 1, i - 1, p) * 2 % p
ans %= p
print(ans)
| false
| 25
|
[
"-問題文は言い換えると、青いボールの連続する区間の数がi個になるような並べ方はいくつあるか。というもの",
"-上記のような並べ方はさらに4種類に分けられる。",
"-(1). 両端が青色になるような並べ方",
"-(2). 両端が赤色になるような並べ方",
"-(3). 左端が赤色、右端が青色になるような並べ方",
"-(4). 左端が青色、右端が赤色になるような並べ方",
"-(1)の場合：A(K個並んでいるの青ボールの隙間にi-1個の赤ボールグループをぶっこむ箇所の場合の数) × B(i-1個のグループに割り振る赤ボールの数)",
"-Aは(k-1)個の隙間から(i-1)個の隙間を選ぶ場合の数なので、(k-1)C(i-1)で計算できる。Bは各グループに最低1個は赤色のボールを割り当てるとして残りN-K-(i-1)をどう分けるか、の場合の数なので、(N-K-(i-1)+(i-2))C(i-2)で計算できる。",
"-(2)の場合：A(K個並んでいるの青ボールの隙間にi-1個の赤ボールグループをぶっこむ箇所の場合の数) × B(i+1個のグループに割り振る赤ボールの数)",
"-Aは(1)と同様なので省略。Bは各グループに最低1個は赤色のボールを割り当てるとして残りN-K-(i+1)をどう分けるか、の場合の数なので、(N-K-(i+1)+i)C(i)で計算できる。",
"-(3)の場合：A(K個並んでいるの青ボールの隙間にi-1個の赤ボールグループをぶっこむ箇所の場合の数) × B(i個のグループに割り振る赤ボールの数)",
"-Aは(1)と同様なので省略。Bは各グループに最低1個は赤色のボールを割り当てるとして残りN-K-iをどう分けるか、の場合の数なので、(N-K-i+(i-1))C(i-1)で計算できる。",
"-(4)は(3)と同様なので省略",
"-なお、赤のボールの数が分割するグループの数以上存在していないと行けないことに注意。",
"+Kをi分割する場合の数＝cmb(K+i-1,i-1)",
"+両端が赤になる場合、両端が青になる場合、左端のみ赤になる場合、右端のみ赤になる場合についてそれぞれ計算すればよい。",
"-def choose(n, k):",
"- import math",
"-",
"- return math.factorial(n) // (math.factorial(n - k) * math.factorial(k))",
"+def cmb(n, r, p):",
"+ if (r < 0) or (n < r):",
"+ return 0",
"+ r = min(r, n - r)",
"+ return fact[n] * factinv[r] * factinv[n - r] % p",
"-mod = 10**9 + 7",
"+p = 10**9 + 7",
"+N = 10**6 # N は必要分だけ用意する",
"+fact = [1, 1] # fact[n] = (n! mod p)",
"+factinv = [1, 1] # factinv[n] = ((n!)^(-1) mod p)",
"+inv = [0, 1] # factinv 計算用",
"+for i in range(2, N + 1):",
"+ fact.append((fact[-1] * i) % p)",
"+ inv.append((-inv[p % i] * (p // i)) % p)",
"+ factinv.append((factinv[-1] * inv[-1]) % p)",
"- A = choose(K - 1, i - 1)",
"- # (1)の場合の数を求める",
"- if N - K >= i - 1:",
"- if i - 2 >= 0:",
"- B = choose(N - K - (i - 1) + (i - 2), i - 2)",
"- ans += A * B",
"- ans %= mod",
"- elif N == K:",
"- ans += 1",
"- if N - K >= i + 1:",
"- B = choose(N - K - (i + 1) + i, i)",
"- ans += A * B",
"- ans %= mod",
"- if N - K >= i:",
"- B = choose(N - K - i + (i - 1), i - 1)",
"- ans += A * B * 2",
"- ans %= mod",
"+ # Kをi分割する場合の数",
"+ divideK = cmb(K - i + i - 1, i - 1, p)",
"+ # 両端が赤の場合の置き方",
"+ ans += divideK * cmb(N - K - (i + 1) + i, i, p) % p",
"+ ans %= p",
"+ # 両端が青の場合の置き方",
"+ if i > 1:",
"+ ans += divideK * cmb(N - K - (i - 1) + i - 2, i - 2, p) % p",
"+ ans %= p",
"+ elif N - K == 0:",
"+ ans += 1",
"+ # 左端のみが赤になる場合の置き方,右端のみが赤になる場合の置き方",
"+ ans += divideK * cmb(N - K - i + i - 1, i - 1, p) * 2 % p",
"+ ans %= p"
] | false
| 0.040388
| 1.949591
| 0.020716
|
[
"s848538600",
"s425604097"
] |
u997641430
|
p02642
|
python
|
s718985336
|
s564519389
| 1,244
| 417
| 104,020
| 218,320
|
Accepted
|
Accepted
| 66.48
|
n = int(eval(input()))
*A, = list(map(int, input().split()))
maxA = max(A)
# C[a] = A内のaの個数
C = {a: 0 for a in A}
for a in A:
C[a] += 1
# D[a]=1: Aにaより小さいaの約数が存在する
D = {a: 0 for a in A}
for a in A:
if C[a] > 0:
tmp = 2
while a * tmp <= maxA:
D[a * tmp] = 1
tmp += 1
ans = 0
for a in A:
if C[a] == 1 and D[a] == 0:
ans += 1
print(ans)
|
n = int(eval(input()))
*A, = list(map(int, input().split()))
maxA = max(A)
C = {a: 0 for a in A}
for a in A:
C[a] += 1
D = {a: 0 for a in A}
for a in A:
if C[a] > 1:
D[a] = 1
for b in range(2 * a, maxA + 1, a):
D[b] = 1
print((sum([D[a] == 0 for a in A])))
| 20
| 13
| 401
| 283
|
n = int(eval(input()))
(*A,) = list(map(int, input().split()))
maxA = max(A)
# C[a] = A内のaの個数
C = {a: 0 for a in A}
for a in A:
C[a] += 1
# D[a]=1: Aにaより小さいaの約数が存在する
D = {a: 0 for a in A}
for a in A:
if C[a] > 0:
tmp = 2
while a * tmp <= maxA:
D[a * tmp] = 1
tmp += 1
ans = 0
for a in A:
if C[a] == 1 and D[a] == 0:
ans += 1
print(ans)
|
n = int(eval(input()))
(*A,) = list(map(int, input().split()))
maxA = max(A)
C = {a: 0 for a in A}
for a in A:
C[a] += 1
D = {a: 0 for a in A}
for a in A:
if C[a] > 1:
D[a] = 1
for b in range(2 * a, maxA + 1, a):
D[b] = 1
print((sum([D[a] == 0 for a in A])))
| false
| 35
|
[
"-# C[a] = A内のaの個数",
"-# D[a]=1: Aにaより小さいaの約数が存在する",
"- if C[a] > 0:",
"- tmp = 2",
"- while a * tmp <= maxA:",
"- D[a * tmp] = 1",
"- tmp += 1",
"-ans = 0",
"-for a in A:",
"- if C[a] == 1 and D[a] == 0:",
"- ans += 1",
"-print(ans)",
"+ if C[a] > 1:",
"+ D[a] = 1",
"+ for b in range(2 * a, maxA + 1, a):",
"+ D[b] = 1",
"+print((sum([D[a] == 0 for a in A])))"
] | false
| 0.12944
| 0.067602
| 1.914743
|
[
"s718985336",
"s564519389"
] |
u047102107
|
p02862
|
python
|
s037782822
|
s448571464
| 485
| 234
| 40,172
| 72,704
|
Accepted
|
Accepted
| 51.75
|
X, Y = list(map(int, input().split()))
MOD = int(1e9 + 7)
def modinv(a, mod=MOD):
return pow(a, mod-2, mod)
def combination(n, r, mod=MOD):
r = min(r, n - r)
res = 1
for i in range(r):
res = res * (n - i) * modinv(i+1, mod) % mod
return res
if (X + Y) % 3 != 0:
print((0))
exit()
b = (2 * Y - X) // 3
a = X - Y + b
if a < 0 or b < 0:
print((0))
exit()
print((combination(a+b, a, MOD)))
|
# https://atcoder.jp/contests/abc145/tasks/abc145_d
X, Y = list(map(int, input().split()))
MOD = int(1e9 + 7)
def combination(n, r, mod=MOD):
def modinv(a, mod=MOD):
return pow(a, mod-2, mod)
# nCr with MOD
r = min(r, n - r)
res = 1
for i in range(r):
res = res * (n - i) * modinv(i+1, mod) % mod
return res
# 1回の移動で3増えるので，X+Yは3の倍数 (0, 0) start
if (X + Y) % 3 != 0:
ans = 0
print((0))
else:
# X+Yは3の倍数
# (+1, +2)をn回，(+2, +1)をm回実行
# n + 2m = X
# 2n + m = Y
# 3 m = 2 X - Y
# m = (2 X - Y) // 3
# n = X - 2 * m
m = (2 * X - Y) // 3
n = X - 2 * m
if m < 0 or n < 0:
print((0))
else:
print((combination(m + n, m, MOD)))
| 26
| 35
| 455
| 761
|
X, Y = list(map(int, input().split()))
MOD = int(1e9 + 7)
def modinv(a, mod=MOD):
return pow(a, mod - 2, mod)
def combination(n, r, mod=MOD):
r = min(r, n - r)
res = 1
for i in range(r):
res = res * (n - i) * modinv(i + 1, mod) % mod
return res
if (X + Y) % 3 != 0:
print((0))
exit()
b = (2 * Y - X) // 3
a = X - Y + b
if a < 0 or b < 0:
print((0))
exit()
print((combination(a + b, a, MOD)))
|
# https://atcoder.jp/contests/abc145/tasks/abc145_d
X, Y = list(map(int, input().split()))
MOD = int(1e9 + 7)
def combination(n, r, mod=MOD):
def modinv(a, mod=MOD):
return pow(a, mod - 2, mod)
# nCr with MOD
r = min(r, n - r)
res = 1
for i in range(r):
res = res * (n - i) * modinv(i + 1, mod) % mod
return res
# 1回の移動で3増えるので，X+Yは3の倍数 (0, 0) start
if (X + Y) % 3 != 0:
ans = 0
print((0))
else:
# X+Yは3の倍数
# (+1, +2)をn回，(+2, +1)をm回実行
# n + 2m = X
# 2n + m = Y
# 3 m = 2 X - Y
# m = (2 X - Y) // 3
# n = X - 2 * m
m = (2 * X - Y) // 3
n = X - 2 * m
if m < 0 or n < 0:
print((0))
else:
print((combination(m + n, m, MOD)))
| false
| 25.714286
|
[
"+# https://atcoder.jp/contests/abc145/tasks/abc145_d",
"-def modinv(a, mod=MOD):",
"- return pow(a, mod - 2, mod)",
"+def combination(n, r, mod=MOD):",
"+ def modinv(a, mod=MOD):",
"+ return pow(a, mod - 2, mod)",
"-",
"-def combination(n, r, mod=MOD):",
"+ # nCr with MOD",
"+# 1回の移動で3増えるので，X+Yは3の倍数 (0, 0) start",
"+ ans = 0",
"- exit()",
"-b = (2 * Y - X) // 3",
"-a = X - Y + b",
"-if a < 0 or b < 0:",
"- print((0))",
"- exit()",
"-print((combination(a + b, a, MOD)))",
"+else:",
"+ # X+Yは3の倍数",
"+ # (+1, +2)をn回，(+2, +1)をm回実行",
"+ # n + 2m = X",
"+ # 2n + m = Y",
"+ # 3 m = 2 X - Y",
"+ # m = (2 X - Y) // 3",
"+ # n = X - 2 * m",
"+ m = (2 * X - Y) // 3",
"+ n = X - 2 * m",
"+ if m < 0 or n < 0:",
"+ print((0))",
"+ else:",
"+ print((combination(m + n, m, MOD)))"
] | false
| 0.511871
| 0.436356
| 1.173059
|
[
"s037782822",
"s448571464"
] |
u129978636
|
p03944
|
python
|
s669222889
|
s639785960
| 19
| 17
| 3,064
| 3,064
|
Accepted
|
Accepted
| 10.53
|
w,h,n=list(map(int,input().split()))
x=[]
y=[]
a=[]
ax=0
ix=w
ay=0
iy=h
for i in range(n):
x1,y1,a1=list(map(int,input().split()))
x.append(x1)
y.append(y1)
a.append(a1)
for j in range(n):
if(a[j]==1):
ax=max(ax,x[j])
elif(a[j]==2):
ix=min(ix,x[j])
elif(a[j]==3):
ay=max(ay,y[j])
else:
iy=min(iy,y[j])
if(ax>=ix or ay>=iy):
print('0')
exit()
else:
print(((ix-ax)*(iy-ay)))
|
w,h,n=list(map(int,input().split()))
ax=0
ix=w
ay=0
iy=h
for i in range(n):
x,y,a=list(map(int,input().split()))
if(a==1):
ax=max(ax,x)
elif(a==2):
ix=min(ix,x)
elif(a==3):
ay=max(ay,y)
else:
iy=min(iy,y)
if(ax>=ix or ay>=iy):
print('0')
exit()
else:
print(((ix-ax)*(iy-ay)))
| 31
| 23
| 468
| 350
|
w, h, n = list(map(int, input().split()))
x = []
y = []
a = []
ax = 0
ix = w
ay = 0
iy = h
for i in range(n):
x1, y1, a1 = list(map(int, input().split()))
x.append(x1)
y.append(y1)
a.append(a1)
for j in range(n):
if a[j] == 1:
ax = max(ax, x[j])
elif a[j] == 2:
ix = min(ix, x[j])
elif a[j] == 3:
ay = max(ay, y[j])
else:
iy = min(iy, y[j])
if ax >= ix or ay >= iy:
print("0")
exit()
else:
print(((ix - ax) * (iy - ay)))
|
w, h, n = list(map(int, input().split()))
ax = 0
ix = w
ay = 0
iy = h
for i in range(n):
x, y, a = list(map(int, input().split()))
if a == 1:
ax = max(ax, x)
elif a == 2:
ix = min(ix, x)
elif a == 3:
ay = max(ay, y)
else:
iy = min(iy, y)
if ax >= ix or ay >= iy:
print("0")
exit()
else:
print(((ix - ax) * (iy - ay)))
| false
| 25.806452
|
[
"-x = []",
"-y = []",
"-a = []",
"- x1, y1, a1 = list(map(int, input().split()))",
"- x.append(x1)",
"- y.append(y1)",
"- a.append(a1)",
"-for j in range(n):",
"- if a[j] == 1:",
"- ax = max(ax, x[j])",
"- elif a[j] == 2:",
"- ix = min(ix, x[j])",
"- elif a[j] == 3:",
"- ay = max(ay, y[j])",
"+ x, y, a = list(map(int, input().split()))",
"+ if a == 1:",
"+ ax = max(ax, x)",
"+ elif a == 2:",
"+ ix = min(ix, x)",
"+ elif a == 3:",
"+ ay = max(ay, y)",
"- iy = min(iy, y[j])",
"+ iy = min(iy, y)"
] | false
| 0.065342
| 0.067506
| 0.967942
|
[
"s669222889",
"s639785960"
] |
u761320129
|
p03416
|
python
|
s423626594
|
s565540311
| 65
| 53
| 3,736
| 2,940
|
Accepted
|
Accepted
| 18.46
|
A,B = list(map(int,input().split()))
print(([str(n)==str(n)[::-1] for n in range(A,B+1)].count(True)))
|
A,B = list(map(int,input().split()))
ans = 0
for n in range(A,B+1):
s = str(n)
if s == s[::-1]:
ans += 1
print(ans)
| 2
| 7
| 95
| 131
|
A, B = list(map(int, input().split()))
print(([str(n) == str(n)[::-1] for n in range(A, B + 1)].count(True)))
|
A, B = list(map(int, input().split()))
ans = 0
for n in range(A, B + 1):
s = str(n)
if s == s[::-1]:
ans += 1
print(ans)
| false
| 71.428571
|
[
"-print(([str(n) == str(n)[::-1] for n in range(A, B + 1)].count(True)))",
"+ans = 0",
"+for n in range(A, B + 1):",
"+ s = str(n)",
"+ if s == s[::-1]:",
"+ ans += 1",
"+print(ans)"
] | false
| 0.066453
| 0.056499
| 1.176183
|
[
"s423626594",
"s565540311"
] |
u254871849
|
p03068
|
python
|
s206472339
|
s126334363
| 25
| 17
| 3,768
| 3,064
|
Accepted
|
Accepted
| 32
|
# 2019-11-23 01:28:44(JST)
import sys
from string import ascii_lowercase as alphabet
def main():
n, s, k = sys.stdin.read().split()
n, k = list(map(int, [n, k]))
c = s[k-1]
for l in alphabet:
if l != c:
s = s.replace(l, '*')
print(s)
if __name__ == '__main__':
main()
|
# 2019-11-23 01:28:44(JST)
import sys
def main():
n, s, k = sys.stdin.read().split()
n, k = list(map(int, [n, k]))
c = s[k-1]
letters = set(s) - set(c)
for l in letters:
s = s.replace(l, '*')
print(s)
if __name__ == '__main__':
main()
| 19
| 17
| 338
| 294
|
# 2019-11-23 01:28:44(JST)
import sys
from string import ascii_lowercase as alphabet
def main():
n, s, k = sys.stdin.read().split()
n, k = list(map(int, [n, k]))
c = s[k - 1]
for l in alphabet:
if l != c:
s = s.replace(l, "*")
print(s)
if __name__ == "__main__":
main()
|
# 2019-11-23 01:28:44(JST)
import sys
def main():
n, s, k = sys.stdin.read().split()
n, k = list(map(int, [n, k]))
c = s[k - 1]
letters = set(s) - set(c)
for l in letters:
s = s.replace(l, "*")
print(s)
if __name__ == "__main__":
main()
| false
| 10.526316
|
[
"-from string import ascii_lowercase as alphabet",
"- for l in alphabet:",
"- if l != c:",
"- s = s.replace(l, \"*\")",
"+ letters = set(s) - set(c)",
"+ for l in letters:",
"+ s = s.replace(l, \"*\")"
] | false
| 0.073992
| 0.062396
| 1.185839
|
[
"s206472339",
"s126334363"
] |
u046158516
|
p02722
|
python
|
s643395037
|
s023269231
| 159
| 94
| 67,888
| 66,656
|
Accepted
|
Accepted
| 40.88
|
N=int(eval(input()))
k=2
ans=1
factors=[]
i=1
while i*i<N-1:
if (N-1)%i==0:
ans+=1
i+=1
while k*k<=N:
n=0
while pow(k,n)<=N:
if (N-pow(k,n))%(pow(k,n+1))==0:
ans+=1
break
n+=1
k+=1
print(ans)
|
n=int(eval(input()))
ans=set()
ans.add(n)
i=2
x = 1
while x * x <= n-1 :
if (n-1) % x == 0:
ans.add(x)
ans.add((n-1)//x)
x += 1
while i*i<=n:
t=n
while t%i==0:
t/=i
if t%i==1:
ans.add(i)
i+=1
print((len(ans)-1))
| 18
| 18
| 236
| 258
|
N = int(eval(input()))
k = 2
ans = 1
factors = []
i = 1
while i * i < N - 1:
if (N - 1) % i == 0:
ans += 1
i += 1
while k * k <= N:
n = 0
while pow(k, n) <= N:
if (N - pow(k, n)) % (pow(k, n + 1)) == 0:
ans += 1
break
n += 1
k += 1
print(ans)
|
n = int(eval(input()))
ans = set()
ans.add(n)
i = 2
x = 1
while x * x <= n - 1:
if (n - 1) % x == 0:
ans.add(x)
ans.add((n - 1) // x)
x += 1
while i * i <= n:
t = n
while t % i == 0:
t /= i
if t % i == 1:
ans.add(i)
i += 1
print((len(ans) - 1))
| false
| 0
|
[
"-N = int(eval(input()))",
"-k = 2",
"-ans = 1",
"-factors = []",
"-i = 1",
"-while i * i < N - 1:",
"- if (N - 1) % i == 0:",
"- ans += 1",
"+n = int(eval(input()))",
"+ans = set()",
"+ans.add(n)",
"+i = 2",
"+x = 1",
"+while x * x <= n - 1:",
"+ if (n - 1) % x == 0:",
"+ ans.add(x)",
"+ ans.add((n - 1) // x)",
"+ x += 1",
"+while i * i <= n:",
"+ t = n",
"+ while t % i == 0:",
"+ t /= i",
"+ if t % i == 1:",
"+ ans.add(i)",
"-while k * k <= N:",
"- n = 0",
"- while pow(k, n) <= N:",
"- if (N - pow(k, n)) % (pow(k, n + 1)) == 0:",
"- ans += 1",
"- break",
"- n += 1",
"- k += 1",
"-print(ans)",
"+print((len(ans) - 1))"
] | false
| 1.226186
| 0.365832
| 3.351774
|
[
"s643395037",
"s023269231"
] |
u620084012
|
p03371
|
python
|
s111828656
|
s759676083
| 232
| 205
| 3,060
| 2,940
|
Accepted
|
Accepted
| 11.64
|
A,B,C,X,Y = list(map(int, input().split()))
ans = A*X+B*Y
for k in range(2*max(X,Y)+1):
ans = min(ans,2*C*k+A*max(0,X-k)+B*max(0,Y-k))
print(ans)
|
A, B, C, X, Y = list(map(int,input().split()))
ans = A*X + B*Y
for k in range(X+Y+1):
ans = min(ans,A*max(0,X-k)+B*max(0,Y-k)+2*k*C)
print(ans)
| 7
| 7
| 151
| 150
|
A, B, C, X, Y = list(map(int, input().split()))
ans = A * X + B * Y
for k in range(2 * max(X, Y) + 1):
ans = min(ans, 2 * C * k + A * max(0, X - k) + B * max(0, Y - k))
print(ans)
|
A, B, C, X, Y = list(map(int, input().split()))
ans = A * X + B * Y
for k in range(X + Y + 1):
ans = min(ans, A * max(0, X - k) + B * max(0, Y - k) + 2 * k * C)
print(ans)
| false
| 0
|
[
"-for k in range(2 * max(X, Y) + 1):",
"- ans = min(ans, 2 * C * k + A * max(0, X - k) + B * max(0, Y - k))",
"+for k in range(X + Y + 1):",
"+ ans = min(ans, A * max(0, X - k) + B * max(0, Y - k) + 2 * k * C)"
] | false
| 0.297322
| 0.092164
| 3.225995
|
[
"s111828656",
"s759676083"
] |
u391731808
|
p03050
|
python
|
s139119496
|
s786728034
| 189
| 120
| 40,300
| 3,424
|
Accepted
|
Accepted
| 36.51
|
N=int(eval(input()))
ans = 0
for r in range(1,int(N**(0.5))+10):
if (N-r)%r==0:
m = (N-r)//r
if m!=0 and r == N//m:
ans += m
print(ans)
|
def get_divisor(n):
a,b = [],[]
for i in range(1,int(n**0.5)+1):
if n%i==0:
a.append(i)
b.append(n//i)
if a[-1]==b[-1]:b.pop()
a.extend(b[::-1])
return a
N = int(eval(input()))
ans = 0
for m in get_divisor(N):
m-=1
if m==0 : continue
if N//m == N%m: ans+=m
print(ans)
| 8
| 17
| 168
| 342
|
N = int(eval(input()))
ans = 0
for r in range(1, int(N ** (0.5)) + 10):
if (N - r) % r == 0:
m = (N - r) // r
if m != 0 and r == N // m:
ans += m
print(ans)
|
def get_divisor(n):
a, b = [], []
for i in range(1, int(n**0.5) + 1):
if n % i == 0:
a.append(i)
b.append(n // i)
if a[-1] == b[-1]:
b.pop()
a.extend(b[::-1])
return a
N = int(eval(input()))
ans = 0
for m in get_divisor(N):
m -= 1
if m == 0:
continue
if N // m == N % m:
ans += m
print(ans)
| false
| 52.941176
|
[
"+def get_divisor(n):",
"+ a, b = [], []",
"+ for i in range(1, int(n**0.5) + 1):",
"+ if n % i == 0:",
"+ a.append(i)",
"+ b.append(n // i)",
"+ if a[-1] == b[-1]:",
"+ b.pop()",
"+ a.extend(b[::-1])",
"+ return a",
"+",
"+",
"-for r in range(1, int(N ** (0.5)) + 10):",
"- if (N - r) % r == 0:",
"- m = (N - r) // r",
"- if m != 0 and r == N // m:",
"- ans += m",
"+for m in get_divisor(N):",
"+ m -= 1",
"+ if m == 0:",
"+ continue",
"+ if N // m == N % m:",
"+ ans += m"
] | false
| 0.210512
| 0.195708
| 1.075642
|
[
"s139119496",
"s786728034"
] |
u369133448
|
p02641
|
python
|
s430663003
|
s385423109
| 22
| 20
| 9,228
| 9,064
|
Accepted
|
Accepted
| 9.09
|
x,n=list(map(int,input().split()))
if n==0:
print(x)
else:
p=list(map(int,input().split()))
dic={}
for i in p:
d=abs(i-x)
if d in dic:
dic[d].append(i)
else:
dic[d]=[i]
sortdic = sorted(list(dic.items()), key=lambda x:x[0])
chk=0
ans=-1
for k,v in sortdic:
if chk==k:
if chk!=0 and len(v)!=2:
if v[0]>x:
ans=x-k
else:
ans=x+k
break
else:
ans=x-chk
break
chk+=1
if ans==-1:
ans=x-chk
print(ans)
|
x,y=list(map(int,input().split()))
if y==0:
print(x)
exit()
p=list(map(int,input().split()))
for i in range(200):
if not x-i in p:
print((x-i))
exit()
if not x+i in p:
print((x+i))
exit()
| 30
| 12
| 532
| 212
|
x, n = list(map(int, input().split()))
if n == 0:
print(x)
else:
p = list(map(int, input().split()))
dic = {}
for i in p:
d = abs(i - x)
if d in dic:
dic[d].append(i)
else:
dic[d] = [i]
sortdic = sorted(list(dic.items()), key=lambda x: x[0])
chk = 0
ans = -1
for k, v in sortdic:
if chk == k:
if chk != 0 and len(v) != 2:
if v[0] > x:
ans = x - k
else:
ans = x + k
break
else:
ans = x - chk
break
chk += 1
if ans == -1:
ans = x - chk
print(ans)
|
x, y = list(map(int, input().split()))
if y == 0:
print(x)
exit()
p = list(map(int, input().split()))
for i in range(200):
if not x - i in p:
print((x - i))
exit()
if not x + i in p:
print((x + i))
exit()
| false
| 60
|
[
"-x, n = list(map(int, input().split()))",
"-if n == 0:",
"+x, y = list(map(int, input().split()))",
"+if y == 0:",
"-else:",
"- p = list(map(int, input().split()))",
"- dic = {}",
"- for i in p:",
"- d = abs(i - x)",
"- if d in dic:",
"- dic[d].append(i)",
"- else:",
"- dic[d] = [i]",
"- sortdic = sorted(list(dic.items()), key=lambda x: x[0])",
"- chk = 0",
"- ans = -1",
"- for k, v in sortdic:",
"- if chk == k:",
"- if chk != 0 and len(v) != 2:",
"- if v[0] > x:",
"- ans = x - k",
"- else:",
"- ans = x + k",
"- break",
"- else:",
"- ans = x - chk",
"- break",
"- chk += 1",
"- if ans == -1:",
"- ans = x - chk",
"- print(ans)",
"+ exit()",
"+p = list(map(int, input().split()))",
"+for i in range(200):",
"+ if not x - i in p:",
"+ print((x - i))",
"+ exit()",
"+ if not x + i in p:",
"+ print((x + i))",
"+ exit()"
] | false
| 0.047405
| 0.038562
| 1.229328
|
[
"s430663003",
"s385423109"
] |
u332906195
|
p02787
|
python
|
s641327316
|
s083199459
| 570
| 507
| 42,844
| 42,972
|
Accepted
|
Accepted
| 11.05
|
H, N = list(map(int, input().split()))
AB = [tuple(map(int, input().split())) for _ in range(N)]
AB.sort(key=lambda x: x[1])
dp = [0] * (H + 1)
for h in range(1, H + 1):
dp[h] = min([dp[max(h - a, 0)] + b for a, b in AB])
print((dp[-1]))
|
H, N = list(map(int, input().split()))
AB = [tuple(map(int, input().split())) for _ in range(N)]
dp = [0] * (H + 1)
for h in range(1, H + 1):
dp[h] = min([dp[max(h - a, 0)] + b for a, b in AB])
print((dp[-1]))
| 9
| 8
| 244
| 215
|
H, N = list(map(int, input().split()))
AB = [tuple(map(int, input().split())) for _ in range(N)]
AB.sort(key=lambda x: x[1])
dp = [0] * (H + 1)
for h in range(1, H + 1):
dp[h] = min([dp[max(h - a, 0)] + b for a, b in AB])
print((dp[-1]))
|
H, N = list(map(int, input().split()))
AB = [tuple(map(int, input().split())) for _ in range(N)]
dp = [0] * (H + 1)
for h in range(1, H + 1):
dp[h] = min([dp[max(h - a, 0)] + b for a, b in AB])
print((dp[-1]))
| false
| 11.111111
|
[
"-AB.sort(key=lambda x: x[1])"
] | false
| 0.076544
| 0.077025
| 0.993745
|
[
"s641327316",
"s083199459"
] |
u347640436
|
p03634
|
python
|
s160934782
|
s981065501
| 725
| 655
| 54,520
| 61,784
|
Accepted
|
Accepted
| 9.66
|
# ダイクストラ法
from heapq import heappop, heappush
N = int(input())
links = [[] for _ in range(N + 1)]
for _ in range(N - 1):
a, b, c = map(int, input().split())
links[a].append((b, c))
links[b].append((a, c))
Q, K = map(int, input().split())
d = [float('inf')] * (N + 1)
d[K] = 0
#prev = [None] * (N + 1)
q = [(0, K)]
while q:
_, u = heappop(q)
for v, c in links[u]:
alt = d[u] + c
if d[v] > alt:
d[v] = alt
#prev[v] = u
heappush(q, (alt, v))
result = []
for _ in range(Q):
x, y = map(int, input().split())
result.append(d[x] + d[y])
print(*result, sep='\n')
#print('\n'.join(str(v) for v in result))
|
# 幅優先探索
from collections import deque
N = int(eval(input()))
links = [[] for _ in range(N + 1)]
for _ in range(N - 1):
a, b, c = list(map(int, input().split()))
links[a].append((b, c))
links[b].append((a, c))
Q, K = list(map(int, input().split()))
d = [float('inf')] * (N + 1)
d[K] = 0
q = deque([K])
while q:
i = q.popleft()
for j, c in links[i]:
if d[i] + c < d[j]:
d[j] = d[i] + c
q.append(j)
result = []
for _ in range(Q):
x, y = list(map(int, input().split()))
result.append(d[x] + d[y])
print(('\n'.join(str(v) for v in result)))
#print(*result, sep='\n')
| 31
| 28
| 711
| 627
|
# ダイクストラ法
from heapq import heappop, heappush
N = int(input())
links = [[] for _ in range(N + 1)]
for _ in range(N - 1):
a, b, c = map(int, input().split())
links[a].append((b, c))
links[b].append((a, c))
Q, K = map(int, input().split())
d = [float("inf")] * (N + 1)
d[K] = 0
# prev = [None] * (N + 1)
q = [(0, K)]
while q:
_, u = heappop(q)
for v, c in links[u]:
alt = d[u] + c
if d[v] > alt:
d[v] = alt
# prev[v] = u
heappush(q, (alt, v))
result = []
for _ in range(Q):
x, y = map(int, input().split())
result.append(d[x] + d[y])
print(*result, sep="\n")
# print('\n'.join(str(v) for v in result))
|
# 幅優先探索
from collections import deque
N = int(eval(input()))
links = [[] for _ in range(N + 1)]
for _ in range(N - 1):
a, b, c = list(map(int, input().split()))
links[a].append((b, c))
links[b].append((a, c))
Q, K = list(map(int, input().split()))
d = [float("inf")] * (N + 1)
d[K] = 0
q = deque([K])
while q:
i = q.popleft()
for j, c in links[i]:
if d[i] + c < d[j]:
d[j] = d[i] + c
q.append(j)
result = []
for _ in range(Q):
x, y = list(map(int, input().split()))
result.append(d[x] + d[y])
print(("\n".join(str(v) for v in result)))
# print(*result, sep='\n')
| false
| 9.677419
|
[
"-# ダイクストラ法",
"-from heapq import heappop, heappush",
"+# 幅優先探索",
"+from collections import deque",
"-N = int(input())",
"+N = int(eval(input()))",
"- a, b, c = map(int, input().split())",
"+ a, b, c = list(map(int, input().split()))",
"-Q, K = map(int, input().split())",
"+Q, K = list(map(int, input().split()))",
"-# prev = [None] * (N + 1)",
"-q = [(0, K)]",
"+q = deque([K])",
"- _, u = heappop(q)",
"- for v, c in links[u]:",
"- alt = d[u] + c",
"- if d[v] > alt:",
"- d[v] = alt",
"- # prev[v] = u",
"- heappush(q, (alt, v))",
"+ i = q.popleft()",
"+ for j, c in links[i]:",
"+ if d[i] + c < d[j]:",
"+ d[j] = d[i] + c",
"+ q.append(j)",
"- x, y = map(int, input().split())",
"+ x, y = list(map(int, input().split()))",
"-print(*result, sep=\"\\n\")",
"-# print('\\n'.join(str(v) for v in result))",
"+print((\"\\n\".join(str(v) for v in result)))",
"+# print(*result, sep='\\n')"
] | false
| 0.050806
| 0.050413
| 1.007801
|
[
"s160934782",
"s981065501"
] |
u588341295
|
p03372
|
python
|
s752920131
|
s632061308
| 643
| 562
| 28,432
| 20,312
|
Accepted
|
Accepted
| 12.6
|
# -*- coding: utf-8 -*-
"""
参考：http://blog.livedoor.jp/misteer/archives/9017497.html
https://www.hamayanhamayan.com/entry/2018/04/21/225805
・累積和
・累積max
"""
N, C = list(map(int, input().split()))
x, v = [0], [0]
for i in range(N):
_x, _v = list(map(int, input().split()))
x.append(_x)
v.append(_v)
# 累積和
sm_r = [0] * (N+1)
for i in range(1, N+1):
sm_r[i] = sm_r[i-1] + v[i] - (x[i] - x[i-1])
sm_l = [0] * (N+1)
sm_l[N] = v[N] - (C - x[N])
for i in range(N-1, 0, -1):
sm_l[i] = sm_l[i+1] + v[i] - (x[i+1] - x[i])
# 累積max
mx_r = [0] * (N+2)
cal = 0
for i in range(1, N+1):
cal += v[i] - (x[i] - x[i-1])
mx_r[i] = max(cal, mx_r[i-1])
mx_l = [0] * (N+2)
mx_l[N] = cal = v[N] - (C - x[N])
for i in range(N-1, 0, -1):
cal += v[i] - (x[i+1] - x[i])
mx_l[i] = max(cal, mx_l[i+1])
ans = 0
for i in range(N+1):
# 右回り→左回り(max(右回りのみ, 逆走もする, 今までの最大))
ans = max(sm_r[i], sm_r[i] - x[i] + mx_l[i+1], ans)
# 左回り→右回り
if i != 0:
ans = max(sm_l[i], sm_l[i] - (C - x[i]) + mx_r[i-1], ans)
print(ans)
|
# -*- coding: utf-8 -*-
"""
参考：http://blog.livedoor.jp/misteer/archives/9017497.html
https://www.hamayanhamayan.com/entry/2018/04/21/225805
・累積max(累積和の応用)
・先に回る方向がiより手前にmaxがあったとしても、
そのパターンは別の周回のiで考慮されているので、
始点まで戻るマイナス分が多くなっていても問題ない。
どのみち先に回る方向で最終的にansに採用されるのはiまで行った時のはず。
"""
N, C = list(map(int, input().split()))
x, v = [0], [0]
for i in range(N):
_x, _v = list(map(int, input().split()))
x.append(_x)
v.append(_v)
# 累積max
mx_r = [0] * (N+2)
cal = 0
for i in range(1, N+1):
cal += v[i] - (x[i] - x[i-1])
mx_r[i] = max(cal, mx_r[i-1])
mx_l = [0] * (N+2)
cal = v[N] - (C - x[N])
mx_l[N] = cal
for i in range(N-1, 0, -1):
cal += v[i] - (x[i+1] - x[i])
mx_l[i] = max(cal, mx_l[i+1])
ans = 0
for i in range(N+1):
# 右回り→左回り(max(右回りのみ, 逆走もする, 今までの最大))
ans = max(mx_r[i], mx_r[i] - x[i] + mx_l[i+1], ans)
# 左回り→右回り
if i != 0:
ans = max(mx_l[i], mx_l[i] - (C - x[i]) + mx_r[i-1], ans)
print(ans)
| 43
| 39
| 1,075
| 975
|
# -*- coding: utf-8 -*-
"""
参考：http://blog.livedoor.jp/misteer/archives/9017497.html
https://www.hamayanhamayan.com/entry/2018/04/21/225805
・累積和
・累積max
"""
N, C = list(map(int, input().split()))
x, v = [0], [0]
for i in range(N):
_x, _v = list(map(int, input().split()))
x.append(_x)
v.append(_v)
# 累積和
sm_r = [0] * (N + 1)
for i in range(1, N + 1):
sm_r[i] = sm_r[i - 1] + v[i] - (x[i] - x[i - 1])
sm_l = [0] * (N + 1)
sm_l[N] = v[N] - (C - x[N])
for i in range(N - 1, 0, -1):
sm_l[i] = sm_l[i + 1] + v[i] - (x[i + 1] - x[i])
# 累積max
mx_r = [0] * (N + 2)
cal = 0
for i in range(1, N + 1):
cal += v[i] - (x[i] - x[i - 1])
mx_r[i] = max(cal, mx_r[i - 1])
mx_l = [0] * (N + 2)
mx_l[N] = cal = v[N] - (C - x[N])
for i in range(N - 1, 0, -1):
cal += v[i] - (x[i + 1] - x[i])
mx_l[i] = max(cal, mx_l[i + 1])
ans = 0
for i in range(N + 1):
# 右回り→左回り(max(右回りのみ, 逆走もする, 今までの最大))
ans = max(sm_r[i], sm_r[i] - x[i] + mx_l[i + 1], ans)
# 左回り→右回り
if i != 0:
ans = max(sm_l[i], sm_l[i] - (C - x[i]) + mx_r[i - 1], ans)
print(ans)
|
# -*- coding: utf-8 -*-
"""
参考：http://blog.livedoor.jp/misteer/archives/9017497.html
https://www.hamayanhamayan.com/entry/2018/04/21/225805
・累積max(累積和の応用)
・先に回る方向がiより手前にmaxがあったとしても、
そのパターンは別の周回のiで考慮されているので、
始点まで戻るマイナス分が多くなっていても問題ない。
どのみち先に回る方向で最終的にansに採用されるのはiまで行った時のはず。
"""
N, C = list(map(int, input().split()))
x, v = [0], [0]
for i in range(N):
_x, _v = list(map(int, input().split()))
x.append(_x)
v.append(_v)
# 累積max
mx_r = [0] * (N + 2)
cal = 0
for i in range(1, N + 1):
cal += v[i] - (x[i] - x[i - 1])
mx_r[i] = max(cal, mx_r[i - 1])
mx_l = [0] * (N + 2)
cal = v[N] - (C - x[N])
mx_l[N] = cal
for i in range(N - 1, 0, -1):
cal += v[i] - (x[i + 1] - x[i])
mx_l[i] = max(cal, mx_l[i + 1])
ans = 0
for i in range(N + 1):
# 右回り→左回り(max(右回りのみ, 逆走もする, 今までの最大))
ans = max(mx_r[i], mx_r[i] - x[i] + mx_l[i + 1], ans)
# 左回り→右回り
if i != 0:
ans = max(mx_l[i], mx_l[i] - (C - x[i]) + mx_r[i - 1], ans)
print(ans)
| false
| 9.302326
|
[
"-・累積和",
"-・累積max",
"+・累積max(累積和の応用)",
"+・先に回る方向がiより手前にmaxがあったとしても、",
"+ そのパターンは別の周回のiで考慮されているので、",
"+ 始点まで戻るマイナス分が多くなっていても問題ない。",
"+ どのみち先に回る方向で最終的にansに採用されるのはiまで行った時のはず。",
"-# 累積和",
"-sm_r = [0] * (N + 1)",
"-for i in range(1, N + 1):",
"- sm_r[i] = sm_r[i - 1] + v[i] - (x[i] - x[i - 1])",
"-sm_l = [0] * (N + 1)",
"-sm_l[N] = v[N] - (C - x[N])",
"-for i in range(N - 1, 0, -1):",
"- sm_l[i] = sm_l[i + 1] + v[i] - (x[i + 1] - x[i])",
"-mx_l[N] = cal = v[N] - (C - x[N])",
"+cal = v[N] - (C - x[N])",
"+mx_l[N] = cal",
"- ans = max(sm_r[i], sm_r[i] - x[i] + mx_l[i + 1], ans)",
"+ ans = max(mx_r[i], mx_r[i] - x[i] + mx_l[i + 1], ans)",
"- ans = max(sm_l[i], sm_l[i] - (C - x[i]) + mx_r[i - 1], ans)",
"+ ans = max(mx_l[i], mx_l[i] - (C - x[i]) + mx_r[i - 1], ans)"
] | false
| 0.044959
| 0.035159
| 1.278746
|
[
"s752920131",
"s632061308"
] |
u863442865
|
p03610
|
python
|
s692488425
|
s757195404
| 36
| 18
| 4,340
| 3,188
|
Accepted
|
Accepted
| 50
|
s = eval(input())
res = []
for i,x in enumerate(list(s)):
if i%2==0:
res.append(x)
print((''.join(res)))
|
s = eval(input())
print((s[::2]))
| 6
| 2
| 113
| 27
|
s = eval(input())
res = []
for i, x in enumerate(list(s)):
if i % 2 == 0:
res.append(x)
print(("".join(res)))
|
s = eval(input())
print((s[::2]))
| false
| 66.666667
|
[
"-res = []",
"-for i, x in enumerate(list(s)):",
"- if i % 2 == 0:",
"- res.append(x)",
"-print((\"\".join(res)))",
"+print((s[::2]))"
] | false
| 0.039934
| 0.081612
| 0.489319
|
[
"s692488425",
"s757195404"
] |
u067227603
|
p02837
|
python
|
s145130027
|
s995473510
| 1,281
| 75
| 3,444
| 9,212
|
Accepted
|
Accepted
| 94.15
|
N = int(eval(input()))
A = []
XY = []
honest_count = []
for i in range (N):
a = int(eval(input()))
A.append(a)
inter = []
for x in range(a):
xy = list(map(int, input().split()))
inter.append(xy)
XY.append(inter)
for i in range(2 ** N):
pt = [0] * N
ck = 1
for j in range(N):
if (i >> j) & 1:
pt[N - j - 1] = 1
for k in range(N): # k人目が正直者の場合チェック
if pt[k] == 1:
for l in range(A[k]):
if XY[k][l][1] != pt[XY[k][l][0] - 1]:
ck = 0
if ck == 1:
honest_count.append(sum(pt))
print((max(honest_count)))
|
import itertools
n = int(eval(input()))
l = []
for i in range(n):
d = int(eval(input()))
for dd in range(d):
x, y = list(map(int, input().split()))
l.append([i, x-1, y])
ans = 0
for p in itertools.product([0, 1], repeat=n):
for ll in l:
if p[ll[0]] == 1 and p[ll[1]] != ll[2]:
break
else:
ans = max(ans, sum(p))
print(ans)
| 31
| 17
| 657
| 381
|
N = int(eval(input()))
A = []
XY = []
honest_count = []
for i in range(N):
a = int(eval(input()))
A.append(a)
inter = []
for x in range(a):
xy = list(map(int, input().split()))
inter.append(xy)
XY.append(inter)
for i in range(2**N):
pt = [0] * N
ck = 1
for j in range(N):
if (i >> j) & 1:
pt[N - j - 1] = 1
for k in range(N): # k人目が正直者の場合チェック
if pt[k] == 1:
for l in range(A[k]):
if XY[k][l][1] != pt[XY[k][l][0] - 1]:
ck = 0
if ck == 1:
honest_count.append(sum(pt))
print((max(honest_count)))
|
import itertools
n = int(eval(input()))
l = []
for i in range(n):
d = int(eval(input()))
for dd in range(d):
x, y = list(map(int, input().split()))
l.append([i, x - 1, y])
ans = 0
for p in itertools.product([0, 1], repeat=n):
for ll in l:
if p[ll[0]] == 1 and p[ll[1]] != ll[2]:
break
else:
ans = max(ans, sum(p))
print(ans)
| false
| 45.16129
|
[
"-N = int(eval(input()))",
"-A = []",
"-XY = []",
"-honest_count = []",
"-for i in range(N):",
"- a = int(eval(input()))",
"- A.append(a)",
"- inter = []",
"- for x in range(a):",
"- xy = list(map(int, input().split()))",
"- inter.append(xy)",
"- XY.append(inter)",
"-for i in range(2**N):",
"- pt = [0] * N",
"- ck = 1",
"- for j in range(N):",
"- if (i >> j) & 1:",
"- pt[N - j - 1] = 1",
"- for k in range(N): # k人目が正直者の場合チェック",
"- if pt[k] == 1:",
"- for l in range(A[k]):",
"- if XY[k][l][1] != pt[XY[k][l][0] - 1]:",
"- ck = 0",
"- if ck == 1:",
"- honest_count.append(sum(pt))",
"-print((max(honest_count)))",
"+import itertools",
"+",
"+n = int(eval(input()))",
"+l = []",
"+for i in range(n):",
"+ d = int(eval(input()))",
"+ for dd in range(d):",
"+ x, y = list(map(int, input().split()))",
"+ l.append([i, x - 1, y])",
"+ans = 0",
"+for p in itertools.product([0, 1], repeat=n):",
"+ for ll in l:",
"+ if p[ll[0]] == 1 and p[ll[1]] != ll[2]:",
"+ break",
"+ else:",
"+ ans = max(ans, sum(p))",
"+print(ans)"
] | false
| 0.093777
| 0.035924
| 2.610435
|
[
"s145130027",
"s995473510"
] |
u863955163
|
p02767
|
python
|
s781770579
|
s336508953
| 21
| 17
| 3,060
| 2,940
|
Accepted
|
Accepted
| 19.05
|
N = int(eval(input()))
X = [int(i) for i in input().split()]
L, R = min(X), max(X)
ans = 10**1000
for i in range(L, R+1):
box = 0
for j in range(N):
box += (X[j] - i)**2
if ans > box:
ans = box
print(ans)
|
N = int(eval(input()))
X = [int(i) for i in input().split()]
P = round(sum(X)/N)
ans = 0
for i in range(N):
ans += (X[i]-P)**2
print(ans)
| 13
| 7
| 241
| 142
|
N = int(eval(input()))
X = [int(i) for i in input().split()]
L, R = min(X), max(X)
ans = 10**1000
for i in range(L, R + 1):
box = 0
for j in range(N):
box += (X[j] - i) ** 2
if ans > box:
ans = box
print(ans)
|
N = int(eval(input()))
X = [int(i) for i in input().split()]
P = round(sum(X) / N)
ans = 0
for i in range(N):
ans += (X[i] - P) ** 2
print(ans)
| false
| 46.153846
|
[
"-L, R = min(X), max(X)",
"-ans = 10**1000",
"-for i in range(L, R + 1):",
"- box = 0",
"- for j in range(N):",
"- box += (X[j] - i) ** 2",
"- if ans > box:",
"- ans = box",
"+P = round(sum(X) / N)",
"+ans = 0",
"+for i in range(N):",
"+ ans += (X[i] - P) ** 2"
] | false
| 0.040861
| 0.057593
| 0.709487
|
[
"s781770579",
"s336508953"
] |
u654470292
|
p03253
|
python
|
s192160540
|
s237660756
| 1,986
| 176
| 115,164
| 38,512
|
Accepted
|
Accepted
| 91.14
|
import sys
import math
def input():
return sys.stdin.readline()[:-1]
def combinations_count(n, r):
return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
def trial_division(n):
factor = []
tmp = int(math.sqrt(n)) + 1
for num in range(2,tmp):
while n % num == 0:
n //= num
factor.append(num)
if n!=1:
factor.append(n)
return factor
n,m=list(map(int,input().split()))
mod=10**9+7
if m==1:
print((1))
quit()
li=trial_division(m)
tmp=li[0]
countli=[]
count=1
for i in range(1,len(li)):
if tmp!=li[i]:
countli.append(count)
count=1
else:
count+=1
tmp=li[i]
countli.append(count)
ans=1
for i in range(len(countli)):
ans*=combinations_count(countli[i]+n-1,countli[i])
print((ans%mod))
|
import sys
import math
def input():
return sys.stdin.readline()[:-1]
def combinations_count(n, r):
return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
def trial_division(n):
factor = []
tmp = int(math.sqrt(n)) + 1
for num in range(2,tmp):
while n % num == 0:
n //= num
factor.append(num)
if n!=1:
factor.append(n)
return factor
n,m=list(map(int,input().split()))
mod=10**9+7
if m==1:
print((1))
quit()
li=trial_division(m)
tmp=li[0]
countli=[]
count=1
for i in range(1,len(li)):
if tmp!=li[i]:
countli.append(count)
count=1
else:
count+=1
tmp=li[i]
countli.append(count)
ans=1
for i in range(len(countli)):
r=countli[i]
s=n+r-1
r=min(r,n-1)
p=1
for j in range(r):
p*=s-j
p//=j+1
ans*=p
ans%=mod
print((ans%mod))
| 40
| 49
| 842
| 933
|
import sys
import math
def input():
return sys.stdin.readline()[:-1]
def combinations_count(n, r):
return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
def trial_division(n):
factor = []
tmp = int(math.sqrt(n)) + 1
for num in range(2, tmp):
while n % num == 0:
n //= num
factor.append(num)
if n != 1:
factor.append(n)
return factor
n, m = list(map(int, input().split()))
mod = 10**9 + 7
if m == 1:
print((1))
quit()
li = trial_division(m)
tmp = li[0]
countli = []
count = 1
for i in range(1, len(li)):
if tmp != li[i]:
countli.append(count)
count = 1
else:
count += 1
tmp = li[i]
countli.append(count)
ans = 1
for i in range(len(countli)):
ans *= combinations_count(countli[i] + n - 1, countli[i])
print((ans % mod))
|
import sys
import math
def input():
return sys.stdin.readline()[:-1]
def combinations_count(n, r):
return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
def trial_division(n):
factor = []
tmp = int(math.sqrt(n)) + 1
for num in range(2, tmp):
while n % num == 0:
n //= num
factor.append(num)
if n != 1:
factor.append(n)
return factor
n, m = list(map(int, input().split()))
mod = 10**9 + 7
if m == 1:
print((1))
quit()
li = trial_division(m)
tmp = li[0]
countli = []
count = 1
for i in range(1, len(li)):
if tmp != li[i]:
countli.append(count)
count = 1
else:
count += 1
tmp = li[i]
countli.append(count)
ans = 1
for i in range(len(countli)):
r = countli[i]
s = n + r - 1
r = min(r, n - 1)
p = 1
for j in range(r):
p *= s - j
p //= j + 1
ans *= p
ans %= mod
print((ans % mod))
| false
| 18.367347
|
[
"- ans *= combinations_count(countli[i] + n - 1, countli[i])",
"+ r = countli[i]",
"+ s = n + r - 1",
"+ r = min(r, n - 1)",
"+ p = 1",
"+ for j in range(r):",
"+ p *= s - j",
"+ p //= j + 1",
"+ ans *= p",
"+ ans %= mod"
] | false
| 0.444766
| 0.048013
| 9.263447
|
[
"s192160540",
"s237660756"
] |
u728566015
|
p02720
|
python
|
s369752350
|
s409004186
| 328
| 179
| 10,740
| 11,776
|
Accepted
|
Accepted
| 45.43
|
import heapq
K = int(eval(input()))
def fun(h, n):
tmp = str(n)
if tmp[-1] == '0':
heapq.heappush(h, int(tmp + '0'))
heapq.heappush(h, int(tmp + '1'))
elif tmp[-1] == '9':
heapq.heappush(h, int(tmp + '8'))
heapq.heappush(h, int(tmp + '9'))
else:
heapq.heappush(h, int(tmp + str(int(tmp[-1]) - 1)))
heapq.heappush(h, int(tmp + tmp[-1]))
heapq.heappush(h, int(tmp + str(int(tmp[-1]) + 1)))
h = list(range(1, 10))
while K > 0:
tmp = heapq.heappop(h)
fun(h, tmp)
K -= 1
else:
print(tmp)
|
import heapq
K = int(eval(input()))
def fun(h, n):
tmp = n % 10
if tmp != 0:
heapq.heappush(h, 10 * n + tmp - 1)
heapq.heappush(h, 10 * n + tmp)
if tmp != 9:
heapq.heappush(h, 10 * n + tmp + 1)
h = list(range(1, 10))
while K > 0:
n = heapq.heappop(h)
fun(h, n)
K -= 1
else:
print(n)
| 25
| 20
| 592
| 347
|
import heapq
K = int(eval(input()))
def fun(h, n):
tmp = str(n)
if tmp[-1] == "0":
heapq.heappush(h, int(tmp + "0"))
heapq.heappush(h, int(tmp + "1"))
elif tmp[-1] == "9":
heapq.heappush(h, int(tmp + "8"))
heapq.heappush(h, int(tmp + "9"))
else:
heapq.heappush(h, int(tmp + str(int(tmp[-1]) - 1)))
heapq.heappush(h, int(tmp + tmp[-1]))
heapq.heappush(h, int(tmp + str(int(tmp[-1]) + 1)))
h = list(range(1, 10))
while K > 0:
tmp = heapq.heappop(h)
fun(h, tmp)
K -= 1
else:
print(tmp)
|
import heapq
K = int(eval(input()))
def fun(h, n):
tmp = n % 10
if tmp != 0:
heapq.heappush(h, 10 * n + tmp - 1)
heapq.heappush(h, 10 * n + tmp)
if tmp != 9:
heapq.heappush(h, 10 * n + tmp + 1)
h = list(range(1, 10))
while K > 0:
n = heapq.heappop(h)
fun(h, n)
K -= 1
else:
print(n)
| false
| 20
|
[
"- tmp = str(n)",
"- if tmp[-1] == \"0\":",
"- heapq.heappush(h, int(tmp + \"0\"))",
"- heapq.heappush(h, int(tmp + \"1\"))",
"- elif tmp[-1] == \"9\":",
"- heapq.heappush(h, int(tmp + \"8\"))",
"- heapq.heappush(h, int(tmp + \"9\"))",
"- else:",
"- heapq.heappush(h, int(tmp + str(int(tmp[-1]) - 1)))",
"- heapq.heappush(h, int(tmp + tmp[-1]))",
"- heapq.heappush(h, int(tmp + str(int(tmp[-1]) + 1)))",
"+ tmp = n % 10",
"+ if tmp != 0:",
"+ heapq.heappush(h, 10 * n + tmp - 1)",
"+ heapq.heappush(h, 10 * n + tmp)",
"+ if tmp != 9:",
"+ heapq.heappush(h, 10 * n + tmp + 1)",
"- tmp = heapq.heappop(h)",
"- fun(h, tmp)",
"+ n = heapq.heappop(h)",
"+ fun(h, n)",
"- print(tmp)",
"+ print(n)"
] | false
| 0.107533
| 0.052195
| 2.060201
|
[
"s369752350",
"s409004186"
] |
u576432509
|
p03637
|
python
|
s935268973
|
s232662199
| 158
| 73
| 14,480
| 14,252
|
Accepted
|
Accepted
| 53.8
|
def mp2(k):
kk=k
mp=0
while kk>=1:
kr=kk%2
if kr==0:
kk=kk//2
mp=mp+1
# print(kk,kr,mp)
else:
# print(kk,kr,mp)
return mp
return mp
n=int(eval(input()))
a=list(map(int,input().split()))
cnt0=0
cnt1=0
cnt2=0
for i in range(n):
m=min(2,mp2(a[i]))
if m==0:
cnt0=cnt0+1
elif m==1:
cnt1=cnt1+1
elif m==2:
cnt2=cnt2+1
#print(cnt0,cnt1,cnt2)
if cnt1==0:
if cnt2>=cnt0-1:
print("Yes")
else:
print("No")
else:
if cnt2>=cnt0:
print("Yes")
else:
print("No")
|
n=int(eval(input()))
a=list(map(int,input().split()))
b4=0
b2=0
b1=0
for i in range(n):
if a[i]%4==0:
b4+=1
elif a[i]%2==0:
b2+=1
else:
b1+=1
if b2==0:
if b1<=b4+1:
print("Yes")
else:
print("No")
else:
if b1<=b4:
print("Yes")
else:
print("No")
| 42
| 25
| 681
| 364
|
def mp2(k):
kk = k
mp = 0
while kk >= 1:
kr = kk % 2
if kr == 0:
kk = kk // 2
mp = mp + 1
# print(kk,kr,mp)
else:
# print(kk,kr,mp)
return mp
return mp
n = int(eval(input()))
a = list(map(int, input().split()))
cnt0 = 0
cnt1 = 0
cnt2 = 0
for i in range(n):
m = min(2, mp2(a[i]))
if m == 0:
cnt0 = cnt0 + 1
elif m == 1:
cnt1 = cnt1 + 1
elif m == 2:
cnt2 = cnt2 + 1
# print(cnt0,cnt1,cnt2)
if cnt1 == 0:
if cnt2 >= cnt0 - 1:
print("Yes")
else:
print("No")
else:
if cnt2 >= cnt0:
print("Yes")
else:
print("No")
|
n = int(eval(input()))
a = list(map(int, input().split()))
b4 = 0
b2 = 0
b1 = 0
for i in range(n):
if a[i] % 4 == 0:
b4 += 1
elif a[i] % 2 == 0:
b2 += 1
else:
b1 += 1
if b2 == 0:
if b1 <= b4 + 1:
print("Yes")
else:
print("No")
else:
if b1 <= b4:
print("Yes")
else:
print("No")
| false
| 40.47619
|
[
"-def mp2(k):",
"- kk = k",
"- mp = 0",
"- while kk >= 1:",
"- kr = kk % 2",
"- if kr == 0:",
"- kk = kk // 2",
"- mp = mp + 1",
"- # print(kk,kr,mp)",
"- else:",
"- # print(kk,kr,mp)",
"- return mp",
"- return mp",
"-",
"-",
"-cnt0 = 0",
"-cnt1 = 0",
"-cnt2 = 0",
"+b4 = 0",
"+b2 = 0",
"+b1 = 0",
"- m = min(2, mp2(a[i]))",
"- if m == 0:",
"- cnt0 = cnt0 + 1",
"- elif m == 1:",
"- cnt1 = cnt1 + 1",
"- elif m == 2:",
"- cnt2 = cnt2 + 1",
"-# print(cnt0,cnt1,cnt2)",
"-if cnt1 == 0:",
"- if cnt2 >= cnt0 - 1:",
"+ if a[i] % 4 == 0:",
"+ b4 += 1",
"+ elif a[i] % 2 == 0:",
"+ b2 += 1",
"+ else:",
"+ b1 += 1",
"+if b2 == 0:",
"+ if b1 <= b4 + 1:",
"- if cnt2 >= cnt0:",
"+ if b1 <= b4:"
] | false
| 0.04404
| 0.047704
| 0.923179
|
[
"s935268973",
"s232662199"
] |
u022979415
|
p03633
|
python
|
s965613941
|
s162043314
| 44
| 38
| 5,512
| 5,384
|
Accepted
|
Accepted
| 13.64
|
from functools import reduce
from fractions import gcd
def find_lcm(a, b):
return a * b // gcd(a, b)
def main():
n = int(eval(input()))
t = [int(eval(input())) for _ in range(n)]
print((reduce(find_lcm, t)))
if __name__ == '__main__':
main()
|
from functools import reduce
from fractions import gcd
def lcm(a, b):
return a * b // gcd(a, b)
def main():
n = int(eval(input()))
t = [int(eval(input())) for _ in range(n)]
print((reduce(lcm, t)))
if __name__ == '__main__':
main()
| 17
| 17
| 271
| 261
|
from functools import reduce
from fractions import gcd
def find_lcm(a, b):
return a * b // gcd(a, b)
def main():
n = int(eval(input()))
t = [int(eval(input())) for _ in range(n)]
print((reduce(find_lcm, t)))
if __name__ == "__main__":
main()
|
from functools import reduce
from fractions import gcd
def lcm(a, b):
return a * b // gcd(a, b)
def main():
n = int(eval(input()))
t = [int(eval(input())) for _ in range(n)]
print((reduce(lcm, t)))
if __name__ == "__main__":
main()
| false
| 0
|
[
"-def find_lcm(a, b):",
"+def lcm(a, b):",
"- print((reduce(find_lcm, t)))",
"+ print((reduce(lcm, t)))"
] | false
| 0.047908
| 0.182033
| 0.263181
|
[
"s965613941",
"s162043314"
] |
u606045429
|
p02883
|
python
|
s203018535
|
s556818631
| 701
| 418
| 127,928
| 53,188
|
Accepted
|
Accepted
| 40.37
|
def main():
N, K, *I = list(map(int, open(0).read().split()))
A, F = I[:N], I[N:]
A.sort()
F.sort(reverse=True)
ng, ok = -1, 10 ** 12
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if sum(max(0, a - mid // f) for a, f in zip(A, F)) <= K:
ok = mid
else:
ng = mid
print(ok)
if __name__ == '__main__':
main()
|
from numpy import array, int64, minimum
def main():
N, K, *I = list(map(int, open(0).read().split()))
A, F = array(I[:N], int64), array(I[N:], int64)
A.sort()
F.sort()
F = F[::-1]
sum_A = A.sum()
ng, ok = -1, 10 ** 12
while ng + 1 < ok:
mid = (ok + ng) // 2
if (sum_A - minimum(A, mid // F).sum()) <= K:
ok = mid
else:
ng = mid
print(ok)
if __name__ == '__main__':
main()
| 20
| 25
| 402
| 485
|
def main():
N, K, *I = list(map(int, open(0).read().split()))
A, F = I[:N], I[N:]
A.sort()
F.sort(reverse=True)
ng, ok = -1, 10**12
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if sum(max(0, a - mid // f) for a, f in zip(A, F)) <= K:
ok = mid
else:
ng = mid
print(ok)
if __name__ == "__main__":
main()
|
from numpy import array, int64, minimum
def main():
N, K, *I = list(map(int, open(0).read().split()))
A, F = array(I[:N], int64), array(I[N:], int64)
A.sort()
F.sort()
F = F[::-1]
sum_A = A.sum()
ng, ok = -1, 10**12
while ng + 1 < ok:
mid = (ok + ng) // 2
if (sum_A - minimum(A, mid // F).sum()) <= K:
ok = mid
else:
ng = mid
print(ok)
if __name__ == "__main__":
main()
| false
| 20
|
[
"+from numpy import array, int64, minimum",
"+",
"+",
"- A, F = I[:N], I[N:]",
"+ A, F = array(I[:N], int64), array(I[N:], int64)",
"- F.sort(reverse=True)",
"+ F.sort()",
"+ F = F[::-1]",
"+ sum_A = A.sum()",
"- while abs(ok - ng) > 1:",
"+ while ng + 1 < ok:",
"- if sum(max(0, a - mid // f) for a, f in zip(A, F)) <= K:",
"+ if (sum_A - minimum(A, mid // F).sum()) <= K:"
] | false
| 0.101381
| 0.37376
| 0.271247
|
[
"s203018535",
"s556818631"
] |
u272525952
|
p03324
|
python
|
s901637745
|
s778729736
| 183
| 168
| 38,384
| 38,484
|
Accepted
|
Accepted
| 8.2
|
a,b=list(map(int,input().split()))
if a==0 and b!=100:
print(b)
elif a==0 and b==100:
print((101))
elif a==1 and b!=100:
print((b*100))
elif a==1 and b==100:
print((10100))
elif a==2 and b!=100:
print((b*10000))
else:
print((101*10**4))
|
a,b=list(map(int,input().split()))
if b==100:
print((101*100**a))
else:
print((b*100**a))
| 15
| 5
| 262
| 87
|
a, b = list(map(int, input().split()))
if a == 0 and b != 100:
print(b)
elif a == 0 and b == 100:
print((101))
elif a == 1 and b != 100:
print((b * 100))
elif a == 1 and b == 100:
print((10100))
elif a == 2 and b != 100:
print((b * 10000))
else:
print((101 * 10**4))
|
a, b = list(map(int, input().split()))
if b == 100:
print((101 * 100**a))
else:
print((b * 100**a))
| false
| 66.666667
|
[
"-if a == 0 and b != 100:",
"- print(b)",
"-elif a == 0 and b == 100:",
"- print((101))",
"-elif a == 1 and b != 100:",
"- print((b * 100))",
"-elif a == 1 and b == 100:",
"- print((10100))",
"-elif a == 2 and b != 100:",
"- print((b * 10000))",
"+if b == 100:",
"+ print((101 * 100**a))",
"- print((101 * 10**4))",
"+ print((b * 100**a))"
] | false
| 0.00874
| 0.035837
| 0.243889
|
[
"s901637745",
"s778729736"
] |
u535803878
|
p02788
|
python
|
s141527041
|
s495945179
| 807
| 661
| 95,440
| 97,032
|
Accepted
|
Accepted
| 18.09
|
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
### BIT
def init(bit, values):
for i,v in enumerate(values):
update(bit,i,v)
#a1 ~ aiまでの和 O(logn)
def query(bit,i):
res = 0
while i > 0:
res += bit[i]
i -= i&(-i)
return res
#ai += x(logN)
def update(bit,i,x):
while i <= len(bit)-1:
bit[i] += x
i += i&(-i)
return
n,d,a = list(map(int, input().split()))
xh = [None]*n
# h = [None]*n
for i in range(n):
xh[i] = tuple(map(int, input().split()))
xh.sort()
bit = [0] * (n+1)
r = 0
val = 0
done = False
for l,(x,h) in enumerate(xh):
bound = x+2*d
while r<n and xh[r][0]<=bound:
r += 1
nokori = h + query(bit, l+1)
if nokori>0:
# print(nokori, a, l, r, bit)
num = nokori//a + int(nokori%a!=0)
val += num
update(bit, l+1, -num*a)
if r<n:
update(bit, r+1, num*a)
print(val)
|
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
n,d,a = list(map(int, input().split()))
xh = [None]*n
# h = [None]*n
for i in range(n):
xh[i] = tuple(map(int, input().split()))
xh.sort()
r = 0
val = 0
from queue import deque
q = deque([])
s = 0
for l,(x,h) in enumerate(xh):
bound = x+2*d
while q and l>=q[0][1]:
s -= q[0][0]
q.popleft()
while r<n and xh[r][0]<=bound:
r += 1
nokori = h - s
if nokori>0:
num = nokori//a + int(nokori%a!=0)
val += num
q.append((num*a, r))
s += num*a
print(val)
| 49
| 34
| 1,048
| 705
|
import sys
input = lambda: sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x + "\n")
### BIT
def init(bit, values):
for i, v in enumerate(values):
update(bit, i, v)
# a1 ~ aiまでの和 O(logn)
def query(bit, i):
res = 0
while i > 0:
res += bit[i]
i -= i & (-i)
return res
# ai += x(logN)
def update(bit, i, x):
while i <= len(bit) - 1:
bit[i] += x
i += i & (-i)
return
n, d, a = list(map(int, input().split()))
xh = [None] * n
# h = [None]*n
for i in range(n):
xh[i] = tuple(map(int, input().split()))
xh.sort()
bit = [0] * (n + 1)
r = 0
val = 0
done = False
for l, (x, h) in enumerate(xh):
bound = x + 2 * d
while r < n and xh[r][0] <= bound:
r += 1
nokori = h + query(bit, l + 1)
if nokori > 0:
# print(nokori, a, l, r, bit)
num = nokori // a + int(nokori % a != 0)
val += num
update(bit, l + 1, -num * a)
if r < n:
update(bit, r + 1, num * a)
print(val)
|
import sys
input = lambda: sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x + "\n")
n, d, a = list(map(int, input().split()))
xh = [None] * n
# h = [None]*n
for i in range(n):
xh[i] = tuple(map(int, input().split()))
xh.sort()
r = 0
val = 0
from queue import deque
q = deque([])
s = 0
for l, (x, h) in enumerate(xh):
bound = x + 2 * d
while q and l >= q[0][1]:
s -= q[0][0]
q.popleft()
while r < n and xh[r][0] <= bound:
r += 1
nokori = h - s
if nokori > 0:
num = nokori // a + int(nokori % a != 0)
val += num
q.append((num * a, r))
s += num * a
print(val)
| false
| 30.612245
|
[
"-### BIT",
"-def init(bit, values):",
"- for i, v in enumerate(values):",
"- update(bit, i, v)",
"-",
"-",
"-# a1 ~ aiまでの和 O(logn)",
"-def query(bit, i):",
"- res = 0",
"- while i > 0:",
"- res += bit[i]",
"- i -= i & (-i)",
"- return res",
"-",
"-",
"-# ai += x(logN)",
"-def update(bit, i, x):",
"- while i <= len(bit) - 1:",
"- bit[i] += x",
"- i += i & (-i)",
"- return",
"-",
"-",
"-bit = [0] * (n + 1)",
"-done = False",
"+from queue import deque",
"+",
"+q = deque([])",
"+s = 0",
"+ while q and l >= q[0][1]:",
"+ s -= q[0][0]",
"+ q.popleft()",
"- nokori = h + query(bit, l + 1)",
"+ nokori = h - s",
"- # print(nokori, a, l, r, bit)",
"- update(bit, l + 1, -num * a)",
"- if r < n:",
"- update(bit, r + 1, num * a)",
"+ q.append((num * a, r))",
"+ s += num * a"
] | false
| 0.107196
| 0.153164
| 0.69988
|
[
"s141527041",
"s495945179"
] |
u729133443
|
p03698
|
python
|
s702873264
|
s523823246
| 174
| 18
| 38,256
| 2,940
|
Accepted
|
Accepted
| 89.66
|
s=eval(input());print(('yneos'[len(s)!=len(set(s))::2]))
|
s=eval(input());print(('yneos'[len(s)>len(set(s))::2]))
| 1
| 1
| 48
| 47
|
s = eval(input())
print(("yneos"[len(s) != len(set(s)) :: 2]))
|
s = eval(input())
print(("yneos"[len(s) > len(set(s)) :: 2]))
| false
| 0
|
[
"-print((\"yneos\"[len(s) != len(set(s)) :: 2]))",
"+print((\"yneos\"[len(s) > len(set(s)) :: 2]))"
] | false
| 0.085628
| 0.036057
| 2.374764
|
[
"s702873264",
"s523823246"
] |
u047796752
|
p03739
|
python
|
s074065483
|
s342146782
| 263
| 99
| 59,120
| 84,380
|
Accepted
|
Accepted
| 62.36
|
import sys
input = sys.stdin.readline
n = int(eval(input()))
a = list(map(int, input().split()))
b = a[:]
acc = 0
for i in range(n):
if i%2==0:
if acc+b[i]<=0:
b[i] += 1-(acc+b[i])
else:
if acc+b[i]>=0:
b[i] -= acc+b[i]+1
acc += b[i]
c = a[:]
acc = 0
for i in range(n):
if i%2==0:
if acc+c[i]>=0:
c[i] -= acc+c[i]+1
else:
if acc+c[i]<=0:
c[i] += 1-(acc+c[i])
acc += c[i]
ans = min(sum(abs(ai-bi) for ai, bi in zip(a, b)), sum(abs(ai-ci) for ai, ci in zip(a, c)))
print(ans)
|
import sys
input = sys.stdin.readline
n = int(eval(input()))
a = list(map(int, input().split()))
cnt1, now = 0, 0
for i in range(n):
now += a[i]
if i%2==0:
if now<=0:
cnt1 += 1-now
now = 1
else:
if now>=0:
cnt1 += now+1
now = -1
cnt2, now = 0, 0
for i in range(n):
now += a[i]
if i%2==1:
if now<=0:
cnt2 += 1-now
now = 1
else:
if now>=0:
cnt2 += now+1
now = -1
print((min(cnt1, cnt2)))
| 35
| 34
| 622
| 581
|
import sys
input = sys.stdin.readline
n = int(eval(input()))
a = list(map(int, input().split()))
b = a[:]
acc = 0
for i in range(n):
if i % 2 == 0:
if acc + b[i] <= 0:
b[i] += 1 - (acc + b[i])
else:
if acc + b[i] >= 0:
b[i] -= acc + b[i] + 1
acc += b[i]
c = a[:]
acc = 0
for i in range(n):
if i % 2 == 0:
if acc + c[i] >= 0:
c[i] -= acc + c[i] + 1
else:
if acc + c[i] <= 0:
c[i] += 1 - (acc + c[i])
acc += c[i]
ans = min(
sum(abs(ai - bi) for ai, bi in zip(a, b)), sum(abs(ai - ci) for ai, ci in zip(a, c))
)
print(ans)
|
import sys
input = sys.stdin.readline
n = int(eval(input()))
a = list(map(int, input().split()))
cnt1, now = 0, 0
for i in range(n):
now += a[i]
if i % 2 == 0:
if now <= 0:
cnt1 += 1 - now
now = 1
else:
if now >= 0:
cnt1 += now + 1
now = -1
cnt2, now = 0, 0
for i in range(n):
now += a[i]
if i % 2 == 1:
if now <= 0:
cnt2 += 1 - now
now = 1
else:
if now >= 0:
cnt2 += now + 1
now = -1
print((min(cnt1, cnt2)))
| false
| 2.857143
|
[
"-b = a[:]",
"-acc = 0",
"+cnt1, now = 0, 0",
"+ now += a[i]",
"- if acc + b[i] <= 0:",
"- b[i] += 1 - (acc + b[i])",
"+ if now <= 0:",
"+ cnt1 += 1 - now",
"+ now = 1",
"- if acc + b[i] >= 0:",
"- b[i] -= acc + b[i] + 1",
"- acc += b[i]",
"-c = a[:]",
"-acc = 0",
"+ if now >= 0:",
"+ cnt1 += now + 1",
"+ now = -1",
"+cnt2, now = 0, 0",
"- if i % 2 == 0:",
"- if acc + c[i] >= 0:",
"- c[i] -= acc + c[i] + 1",
"+ now += a[i]",
"+ if i % 2 == 1:",
"+ if now <= 0:",
"+ cnt2 += 1 - now",
"+ now = 1",
"- if acc + c[i] <= 0:",
"- c[i] += 1 - (acc + c[i])",
"- acc += c[i]",
"-ans = min(",
"- sum(abs(ai - bi) for ai, bi in zip(a, b)), sum(abs(ai - ci) for ai, ci in zip(a, c))",
"-)",
"-print(ans)",
"+ if now >= 0:",
"+ cnt2 += now + 1",
"+ now = -1",
"+print((min(cnt1, cnt2)))"
] | false
| 0.032588
| 0.035612
| 0.91508
|
[
"s074065483",
"s342146782"
] |
u977389981
|
p02981
|
python
|
s097039038
|
s978123162
| 182
| 17
| 38,384
| 2,940
|
Accepted
|
Accepted
| 90.66
|
N, A, B = list(map(int, input().split()))
print((min(A * N, B)))
|
N, A, B = list(map(int, input().split()))
print((min(N * A, B)))
| 3
| 2
| 59
| 57
|
N, A, B = list(map(int, input().split()))
print((min(A * N, B)))
|
N, A, B = list(map(int, input().split()))
print((min(N * A, B)))
| false
| 33.333333
|
[
"-print((min(A * N, B)))",
"+print((min(N * A, B)))"
] | false
| 0.065063
| 0.033519
| 1.941073
|
[
"s097039038",
"s978123162"
] |
u922449550
|
p02574
|
python
|
s663167267
|
s467429934
| 891
| 527
| 150,048
| 228,172
|
Accepted
|
Accepted
| 40.85
|
import numpy as np
N = int(eval(input()))
A = list(map(int, input().split()))
exist = [0] * (10**6 + 1)
for a in A:
exist[a] += 1
if np.gcd.reduce(A) != 1:
print('not coprime')
elif np.all([sum(exist[i::i]) <= 1 for i in range(2, 10**6+1)]):
print('pairwise coprime')
else:
print('setwise coprime')
|
from math import gcd
N = int(eval(input()))
A = list(map(int, input().split()))
exist = [0] * (10**6 + 1)
for a in A:
exist[a] += 1
g = A[0]
for a in A[1:]:
g = gcd(g, a)
if g != 1:
print('not coprime')
elif all([sum(exist[i::i]) <= 1 for i in range(2, 10**6+1)]):
print('pairwise coprime')
else:
print('setwise coprime')
| 14
| 18
| 323
| 355
|
import numpy as np
N = int(eval(input()))
A = list(map(int, input().split()))
exist = [0] * (10**6 + 1)
for a in A:
exist[a] += 1
if np.gcd.reduce(A) != 1:
print("not coprime")
elif np.all([sum(exist[i::i]) <= 1 for i in range(2, 10**6 + 1)]):
print("pairwise coprime")
else:
print("setwise coprime")
|
from math import gcd
N = int(eval(input()))
A = list(map(int, input().split()))
exist = [0] * (10**6 + 1)
for a in A:
exist[a] += 1
g = A[0]
for a in A[1:]:
g = gcd(g, a)
if g != 1:
print("not coprime")
elif all([sum(exist[i::i]) <= 1 for i in range(2, 10**6 + 1)]):
print("pairwise coprime")
else:
print("setwise coprime")
| false
| 22.222222
|
[
"-import numpy as np",
"+from math import gcd",
"-if np.gcd.reduce(A) != 1:",
"+g = A[0]",
"+for a in A[1:]:",
"+ g = gcd(g, a)",
"+if g != 1:",
"-elif np.all([sum(exist[i::i]) <= 1 for i in range(2, 10**6 + 1)]):",
"+elif all([sum(exist[i::i]) <= 1 for i in range(2, 10**6 + 1)]):"
] | false
| 0.885689
| 1.086014
| 0.815541
|
[
"s663167267",
"s467429934"
] |
u671060652
|
p03208
|
python
|
s842224473
|
s713060072
| 658
| 205
| 76,116
| 87,332
|
Accepted
|
Accepted
| 68.84
|
import itertools
import math
import fractions
import functools
import copy
n, k = list(map(int, input().split()))
h = []
for i in range(n):
h.append(int(eval(input())))
h.sort()
minimum = 10**10
for i in range(n-k+1):
minimum = min(minimum,h[i+k-1]-h[i])
print(minimum)
|
def main():
# n = int(input())
n, m = list(map(int, input().split()))
# v = list(map(int, input().split()))
# s = input()
h = [int(eval(input())) for _ in range(n)]
h.sort()
temp = []
for i in range(n-m+1):
temp.append(h[i+m-1]-h[i])
temp.sort()
print((temp[0]))
if __name__ == '__main__':
main()
| 17
| 19
| 284
| 358
|
import itertools
import math
import fractions
import functools
import copy
n, k = list(map(int, input().split()))
h = []
for i in range(n):
h.append(int(eval(input())))
h.sort()
minimum = 10**10
for i in range(n - k + 1):
minimum = min(minimum, h[i + k - 1] - h[i])
print(minimum)
|
def main():
# n = int(input())
n, m = list(map(int, input().split()))
# v = list(map(int, input().split()))
# s = input()
h = [int(eval(input())) for _ in range(n)]
h.sort()
temp = []
for i in range(n - m + 1):
temp.append(h[i + m - 1] - h[i])
temp.sort()
print((temp[0]))
if __name__ == "__main__":
main()
| false
| 10.526316
|
[
"-import itertools",
"-import math",
"-import fractions",
"-import functools",
"-import copy",
"+def main():",
"+ # n = int(input())",
"+ n, m = list(map(int, input().split()))",
"+ # v = list(map(int, input().split()))",
"+ # s = input()",
"+ h = [int(eval(input())) for _ in range(n)]",
"+ h.sort()",
"+ temp = []",
"+ for i in range(n - m + 1):",
"+ temp.append(h[i + m - 1] - h[i])",
"+ temp.sort()",
"+ print((temp[0]))",
"-n, k = list(map(int, input().split()))",
"-h = []",
"-for i in range(n):",
"- h.append(int(eval(input())))",
"-h.sort()",
"-minimum = 10**10",
"-for i in range(n - k + 1):",
"- minimum = min(minimum, h[i + k - 1] - h[i])",
"-print(minimum)",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false
| 0.045477
| 0.04135
| 1.09982
|
[
"s842224473",
"s713060072"
] |
u561083515
|
p03352
|
python
|
s633334903
|
s683187005
| 21
| 17
| 2,940
| 2,940
|
Accepted
|
Accepted
| 19.05
|
X = int(eval(input()))
ans = 0
for i in range(1,1001):
for j in range(2,11):
tmp = i ** j
if tmp <= X:
ans = max(ans, i ** j)
print(ans)
|
X = int(eval(input()))
ans = 1
for i in range(2,int(X**.5)+1):
j = 2
while i ** j <= X:
ans = max(ans, i ** j)
j += 1
print(ans)
| 10
| 10
| 173
| 157
|
X = int(eval(input()))
ans = 0
for i in range(1, 1001):
for j in range(2, 11):
tmp = i**j
if tmp <= X:
ans = max(ans, i**j)
print(ans)
|
X = int(eval(input()))
ans = 1
for i in range(2, int(X**0.5) + 1):
j = 2
while i**j <= X:
ans = max(ans, i**j)
j += 1
print(ans)
| false
| 0
|
[
"-ans = 0",
"-for i in range(1, 1001):",
"- for j in range(2, 11):",
"- tmp = i**j",
"- if tmp <= X:",
"- ans = max(ans, i**j)",
"+ans = 1",
"+for i in range(2, int(X**0.5) + 1):",
"+ j = 2",
"+ while i**j <= X:",
"+ ans = max(ans, i**j)",
"+ j += 1"
] | false
| 0.05702
| 0.047962
| 1.188861
|
[
"s633334903",
"s683187005"
] |
u970308980
|
p03061
|
python
|
s730911478
|
s718397977
| 265
| 188
| 65,124
| 16,144
|
Accepted
|
Accepted
| 29.06
|
# 最大公約数
def gcd(a, b):
while b:
a, b = b, a % b
return a
N = int(eval(input()))
A = list(map(int, input().split()))
L = [0 for _ in range(N)]
R = [0 for _ in range(N)]
L[0] = A[0]
R[N-1] = A[N-1]
for i in range(1, N):
L[i] = gcd(L[i-1], A[i])
for i in reversed(list(range(N-1))):
R[i] = gcd(R[i+1], A[i])
ans = 0
for i in range(N):
if i == 0:
ans = max(ans, R[i+1])
elif i == N-1:
ans = max(ans, L[i-1])
else:
ans = max(ans, gcd(L[i-1], R[i+1]))
print(ans)
|
from itertools import accumulate
from fractions import gcd
N = int(eval(input()))
A = list(map(int, input().split()))
cum_gcd_l = list(accumulate(A, gcd))
cum_gcd_r = list(accumulate(reversed(A), gcd))
ans = 0
for i in range(N):
if i == 0:
tmp = cum_gcd_r[-2]
elif i == N-1:
tmp = cum_gcd_l[-2]
else:
tmp = gcd(cum_gcd_l[i-1], cum_gcd_r[N-i-2])
ans = max(tmp, ans)
print(ans)
| 33
| 22
| 545
| 437
|
# 最大公約数
def gcd(a, b):
while b:
a, b = b, a % b
return a
N = int(eval(input()))
A = list(map(int, input().split()))
L = [0 for _ in range(N)]
R = [0 for _ in range(N)]
L[0] = A[0]
R[N - 1] = A[N - 1]
for i in range(1, N):
L[i] = gcd(L[i - 1], A[i])
for i in reversed(list(range(N - 1))):
R[i] = gcd(R[i + 1], A[i])
ans = 0
for i in range(N):
if i == 0:
ans = max(ans, R[i + 1])
elif i == N - 1:
ans = max(ans, L[i - 1])
else:
ans = max(ans, gcd(L[i - 1], R[i + 1]))
print(ans)
|
from itertools import accumulate
from fractions import gcd
N = int(eval(input()))
A = list(map(int, input().split()))
cum_gcd_l = list(accumulate(A, gcd))
cum_gcd_r = list(accumulate(reversed(A), gcd))
ans = 0
for i in range(N):
if i == 0:
tmp = cum_gcd_r[-2]
elif i == N - 1:
tmp = cum_gcd_l[-2]
else:
tmp = gcd(cum_gcd_l[i - 1], cum_gcd_r[N - i - 2])
ans = max(tmp, ans)
print(ans)
| false
| 33.333333
|
[
"-# 最大公約数",
"-def gcd(a, b):",
"- while b:",
"- a, b = b, a % b",
"- return a",
"-",
"+from itertools import accumulate",
"+from fractions import gcd",
"-L = [0 for _ in range(N)]",
"-R = [0 for _ in range(N)]",
"-L[0] = A[0]",
"-R[N - 1] = A[N - 1]",
"-for i in range(1, N):",
"- L[i] = gcd(L[i - 1], A[i])",
"-for i in reversed(list(range(N - 1))):",
"- R[i] = gcd(R[i + 1], A[i])",
"+cum_gcd_l = list(accumulate(A, gcd))",
"+cum_gcd_r = list(accumulate(reversed(A), gcd))",
"- ans = max(ans, R[i + 1])",
"+ tmp = cum_gcd_r[-2]",
"- ans = max(ans, L[i - 1])",
"+ tmp = cum_gcd_l[-2]",
"- ans = max(ans, gcd(L[i - 1], R[i + 1]))",
"+ tmp = gcd(cum_gcd_l[i - 1], cum_gcd_r[N - i - 2])",
"+ ans = max(tmp, ans)"
] | false
| 0.044262
| 0.05098
| 0.868216
|
[
"s730911478",
"s718397977"
] |
u285891772
|
p03231
|
python
|
s598737579
|
s540895315
| 88
| 39
| 5,460
| 5,472
|
Accepted
|
Accepted
| 55.68
|
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees#, log2
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left, insort, insort_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(str, input().split()))
def ZIP(n): return list(zip(*(MAP() for _ in range(n))))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10**9 + 7
#from decimal import *
N, M = MAP()
S = eval(input())
T = eval(input())
if S[0] != T[0]:
print((-1))
exit()
G = gcd(N, M)
n = N//G
m = M//G
for i in range(G):
if S[::n][i] != T[::m][i]:
print((-1))
break
else:
print((N*M//G))
|
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees#, log2
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left, insort, insort_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(str, input().split()))
def ZIP(n): return list(zip(*(MAP() for _ in range(n))))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10**9 + 7
#from decimal import *
N, M = MAP()
S = eval(input())
T = eval(input())
L = N*M//gcd(N, M)
G = gcd(N, M)
for i in range(G):
if S[N//G*i] != T[M//G*i]:
print((-1))
break
else:
print(L)
| 41
| 38
| 1,113
| 1,071
|
import sys, re
from collections import deque, defaultdict, Counter
from math import (
ceil,
sqrt,
hypot,
factorial,
pi,
sin,
cos,
tan,
asin,
acos,
atan,
radians,
degrees,
) # , log2
from itertools import (
accumulate,
permutations,
combinations,
combinations_with_replacement,
product,
groupby,
)
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left, insort, insort_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
def input():
return sys.stdin.readline().strip()
def INT():
return int(eval(input()))
def MAP():
return list(map(int, input().split()))
def LIST():
return list(map(str, input().split()))
def ZIP(n):
return list(zip(*(MAP() for _ in range(n))))
sys.setrecursionlimit(10**9)
INF = float("inf")
mod = 10**9 + 7
# from decimal import *
N, M = MAP()
S = eval(input())
T = eval(input())
if S[0] != T[0]:
print((-1))
exit()
G = gcd(N, M)
n = N // G
m = M // G
for i in range(G):
if S[::n][i] != T[::m][i]:
print((-1))
break
else:
print((N * M // G))
|
import sys, re
from collections import deque, defaultdict, Counter
from math import (
ceil,
sqrt,
hypot,
factorial,
pi,
sin,
cos,
tan,
asin,
acos,
atan,
radians,
degrees,
) # , log2
from itertools import (
accumulate,
permutations,
combinations,
combinations_with_replacement,
product,
groupby,
)
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left, insort, insort_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
def input():
return sys.stdin.readline().strip()
def INT():
return int(eval(input()))
def MAP():
return list(map(int, input().split()))
def LIST():
return list(map(str, input().split()))
def ZIP(n):
return list(zip(*(MAP() for _ in range(n))))
sys.setrecursionlimit(10**9)
INF = float("inf")
mod = 10**9 + 7
# from decimal import *
N, M = MAP()
S = eval(input())
T = eval(input())
L = N * M // gcd(N, M)
G = gcd(N, M)
for i in range(G):
if S[N // G * i] != T[M // G * i]:
print((-1))
break
else:
print(L)
| false
| 7.317073
|
[
"-if S[0] != T[0]:",
"- print((-1))",
"- exit()",
"+L = N * M // gcd(N, M)",
"-n = N // G",
"-m = M // G",
"- if S[::n][i] != T[::m][i]:",
"+ if S[N // G * i] != T[M // G * i]:",
"- print((N * M // G))",
"+ print(L)"
] | false
| 0.04553
| 0.046038
| 0.988961
|
[
"s598737579",
"s540895315"
] |
u606523772
|
p02791
|
python
|
s014065423
|
s049397659
| 131
| 112
| 24,744
| 24,744
|
Accepted
|
Accepted
| 14.5
|
N = int(eval(input()))
P = list(map(int, input().split()))
cnt = 0
P_min = 200000
for i in range(N):
if P_min > P[i]:
P_min = P[i]
if P_min == P[i]:
cnt += 1
print(cnt)
|
N = int(eval(input()))
A_list = list(map(int, input().split()))
min1 = A_list[0]
cnt = 0
for i in range(N):
if A_list[i] <= min1:
min1 = A_list[i]
cnt += 1
print(cnt)
| 10
| 9
| 195
| 188
|
N = int(eval(input()))
P = list(map(int, input().split()))
cnt = 0
P_min = 200000
for i in range(N):
if P_min > P[i]:
P_min = P[i]
if P_min == P[i]:
cnt += 1
print(cnt)
|
N = int(eval(input()))
A_list = list(map(int, input().split()))
min1 = A_list[0]
cnt = 0
for i in range(N):
if A_list[i] <= min1:
min1 = A_list[i]
cnt += 1
print(cnt)
| false
| 10
|
[
"-P = list(map(int, input().split()))",
"+A_list = list(map(int, input().split()))",
"+min1 = A_list[0]",
"-P_min = 200000",
"- if P_min > P[i]:",
"- P_min = P[i]",
"- if P_min == P[i]:",
"+ if A_list[i] <= min1:",
"+ min1 = A_list[i]"
] | false
| 0.046188
| 0.045457
| 1.016084
|
[
"s014065423",
"s049397659"
] |
u275666666
|
p02689
|
python
|
s098538824
|
s928206831
| 386
| 307
| 121,048
| 127,268
|
Accepted
|
Accepted
| 20.47
|
def get_unique_list(seq):
seen = []
return [x for x in seq if x not in seen and not seen.append(x)]
N,M=list(map(int, input().split()))
H=list(map(int, input().split()))
AB = [list(map(int, input().split())) for i in range(int(M))]
AB_unique=list(map(list, set(map(tuple, AB))))
AB_road=[True]*N
for AB in AB_unique:
if H[AB[0]-1] > H[AB[1]-1]:
AB_road[AB[1]-1]=False
elif H[AB[0]-1] < H[AB[1]-1]:
AB_road[AB[0]-1]=False
else:
AB_road[AB[1]-1]=False
AB_road[AB[0]-1]=False
print((AB_road.count(True)))
|
N,M=list(map(int, input().split()))
H=list(map(int, input().split()))
AB = [list(map(int, input().split())) for i in range(int(M))]
AB_unique=list(map(list, set(map(tuple, AB))))
AB_road=[[] for i in range(N)]
for AB in AB_unique:
if H[AB[0]-1] > H[AB[1]-1]:
AB_road[AB[1]-1].append(AB[0])
elif H[AB[0]-1] < H[AB[1]-1]:
AB_road[AB[0]-1].append(AB[1])
else:
AB_road[AB[1]-1].append(AB[0])
AB_road[AB[0]-1].append(AB[1])
print((AB_road.count([])))
| 21
| 17
| 569
| 500
|
def get_unique_list(seq):
seen = []
return [x for x in seq if x not in seen and not seen.append(x)]
N, M = list(map(int, input().split()))
H = list(map(int, input().split()))
AB = [list(map(int, input().split())) for i in range(int(M))]
AB_unique = list(map(list, set(map(tuple, AB))))
AB_road = [True] * N
for AB in AB_unique:
if H[AB[0] - 1] > H[AB[1] - 1]:
AB_road[AB[1] - 1] = False
elif H[AB[0] - 1] < H[AB[1] - 1]:
AB_road[AB[0] - 1] = False
else:
AB_road[AB[1] - 1] = False
AB_road[AB[0] - 1] = False
print((AB_road.count(True)))
|
N, M = list(map(int, input().split()))
H = list(map(int, input().split()))
AB = [list(map(int, input().split())) for i in range(int(M))]
AB_unique = list(map(list, set(map(tuple, AB))))
AB_road = [[] for i in range(N)]
for AB in AB_unique:
if H[AB[0] - 1] > H[AB[1] - 1]:
AB_road[AB[1] - 1].append(AB[0])
elif H[AB[0] - 1] < H[AB[1] - 1]:
AB_road[AB[0] - 1].append(AB[1])
else:
AB_road[AB[1] - 1].append(AB[0])
AB_road[AB[0] - 1].append(AB[1])
print((AB_road.count([])))
| false
| 19.047619
|
[
"-def get_unique_list(seq):",
"- seen = []",
"- return [x for x in seq if x not in seen and not seen.append(x)]",
"-",
"-",
"-AB_road = [True] * N",
"+AB_road = [[] for i in range(N)]",
"- AB_road[AB[1] - 1] = False",
"+ AB_road[AB[1] - 1].append(AB[0])",
"- AB_road[AB[0] - 1] = False",
"+ AB_road[AB[0] - 1].append(AB[1])",
"- AB_road[AB[1] - 1] = False",
"- AB_road[AB[0] - 1] = False",
"-print((AB_road.count(True)))",
"+ AB_road[AB[1] - 1].append(AB[0])",
"+ AB_road[AB[0] - 1].append(AB[1])",
"+print((AB_road.count([])))"
] | false
| 0.04543
| 0.086269
| 0.526617
|
[
"s098538824",
"s928206831"
] |
u729133443
|
p03146
|
python
|
s262491485
|
s618962068
| 165
| 20
| 38,384
| 2,940
|
Accepted
|
Accepted
| 87.88
|
def fun(n):
if n%2:return 3*n+1
return n//2
a=[0]+[int(eval(input()))]
i=1
while not fun(a[i]) in a:a.append(fun(a[i]));i+=1
print((i+1))
|
s=int(eval(input()))
i=2
while~-s:s=[s//2,s*3+1][s%2];i+=1
print((max(i,4)))
| 7
| 4
| 143
| 71
|
def fun(n):
if n % 2:
return 3 * n + 1
return n // 2
a = [0] + [int(eval(input()))]
i = 1
while not fun(a[i]) in a:
a.append(fun(a[i]))
i += 1
print((i + 1))
|
s = int(eval(input()))
i = 2
while ~-s:
s = [s // 2, s * 3 + 1][s % 2]
i += 1
print((max(i, 4)))
| false
| 42.857143
|
[
"-def fun(n):",
"- if n % 2:",
"- return 3 * n + 1",
"- return n // 2",
"-",
"-",
"-a = [0] + [int(eval(input()))]",
"-i = 1",
"-while not fun(a[i]) in a:",
"- a.append(fun(a[i]))",
"+s = int(eval(input()))",
"+i = 2",
"+while ~-s:",
"+ s = [s // 2, s * 3 + 1][s % 2]",
"-print((i + 1))",
"+print((max(i, 4)))"
] | false
| 0.079497
| 0.042205
| 1.883573
|
[
"s262491485",
"s618962068"
] |
u906501980
|
p03379
|
python
|
s592210041
|
s206470781
| 324
| 299
| 26,772
| 26,772
|
Accepted
|
Accepted
| 7.72
|
n=int(eval(input()))
x=list(map(int,input().split()))
y = sorted(x)
x1, x2 = y[n//2-1], y[n//2]
for i in range(n):
if x[i]<=x1:
print(x2)
else:
print(x1)
|
n = int(eval(input()))
x = list(map(int,input().split()))
y = sorted(x)
x1, x2 = y[n//2-1], y[n//2]
for i, xx in enumerate(x):
if xx<=x1:
print(x2)
else:
print(x1)
| 9
| 9
| 180
| 190
|
n = int(eval(input()))
x = list(map(int, input().split()))
y = sorted(x)
x1, x2 = y[n // 2 - 1], y[n // 2]
for i in range(n):
if x[i] <= x1:
print(x2)
else:
print(x1)
|
n = int(eval(input()))
x = list(map(int, input().split()))
y = sorted(x)
x1, x2 = y[n // 2 - 1], y[n // 2]
for i, xx in enumerate(x):
if xx <= x1:
print(x2)
else:
print(x1)
| false
| 0
|
[
"-for i in range(n):",
"- if x[i] <= x1:",
"+for i, xx in enumerate(x):",
"+ if xx <= x1:"
] | false
| 0.046683
| 0.048377
| 0.964983
|
[
"s592210041",
"s206470781"
] |
u308684517
|
p03814
|
python
|
s984478014
|
s771280999
| 61
| 35
| 3,512
| 3,516
|
Accepted
|
Accepted
| 42.62
|
s = eval(input())
flag = True
for i in range(len(s)):
if s[i] == "A" and flag :
a = i
flag = False
if s[i] == "Z" and not flag:
z = i
print((z-a+1))
|
s = eval(input())
flag = True
for i in range(len(s)):
if s[i] == "A":
a = i
break
for i in range(len(s)-1, 0, -1):
if s[i] == "Z":
z = i
break
print((z-a+1))
| 9
| 11
| 180
| 203
|
s = eval(input())
flag = True
for i in range(len(s)):
if s[i] == "A" and flag:
a = i
flag = False
if s[i] == "Z" and not flag:
z = i
print((z - a + 1))
|
s = eval(input())
flag = True
for i in range(len(s)):
if s[i] == "A":
a = i
break
for i in range(len(s) - 1, 0, -1):
if s[i] == "Z":
z = i
break
print((z - a + 1))
| false
| 18.181818
|
[
"- if s[i] == \"A\" and flag:",
"+ if s[i] == \"A\":",
"- flag = False",
"- if s[i] == \"Z\" and not flag:",
"+ break",
"+for i in range(len(s) - 1, 0, -1):",
"+ if s[i] == \"Z\":",
"+ break"
] | false
| 0.040683
| 0.041043
| 0.991235
|
[
"s984478014",
"s771280999"
] |
u379629675
|
p02913
|
python
|
s069648551
|
s130074679
| 94
| 67
| 5,372
| 4,204
|
Accepted
|
Accepted
| 28.72
|
import sys
from collections import defaultdict
# input関係の定義
sys.setrecursionlimit(200000)
input = sys.stdin.readline
def ii(): return int(input())
def mi(): return map(int, input().rstrip().split())
def lmi(): return list(map(int, input().rstrip().split()))
def fi(): return float(input())
def mfi(): return map(float, input().rstrip().split())
def lmfi(): return list(map(float, input().rstrip().split()))
def li(): return list(input().rstrip())
def debug(*args, sep=" ", end="\n"): print("debug:", *args, file=sys.stderr, sep=sep, end=end) if not __debug__ else None
def exit(*arg): print(*arg); sys.exit()
# template
# BEGIN CUT HERE
class RollingHash():
BASE1 = 1007
BASE2 = 2009
MOD1 = 1000000007
MOD2 = 1000000009
def __init__(self, s):
self.n = len(s)
self.hash1 = [0] * (self.n + 1)
self.hash2 = [0] * (self.n + 1)
self.power1 = [1] * (self.n + 1)
self.power2 = [1] * (self.n + 1)
for i, e in enumerate(s):
self.hash1[i + 1] = (self.hash1[i] * self.__class__.BASE1 + ord(e)) % self.__class__.MOD1
self.hash2[i + 1] = (self.hash2[i] * self.__class__.BASE2 + ord(e)) % self.__class__.MOD2
self.power1[i + 1] = (self.power1[i] * self.__class__.BASE1) % self.__class__.MOD1
self.power2[i + 1] = (self.power2[i] * self.__class__.BASE2) % self.__class__.MOD2
def get(self, l: int, r: int):
res1 = self.hash1[r] - self.hash1[l] * self.power1[r - l] % self.__class__.MOD1
if(res1 < 0):
res1 += self.__class__.MOD1
res2 = self.hash2[r] - self.hash2[l] * self.power2[r - l] % self.__class__.MOD2
if(res2 < 0):
res2 += self.__class__.MOD2
return (res1, res2)
# END CUT HERE
def ABC131E():
N = ii()
S = li()
rh = RollingHash(S)
def check(n: int):
d = dict()
for i in range(N - n + 1):
p = rh.get(i, i + n)
if p in d.keys():
if(i - d[p] >= n):
return True
else:
d[p] = i
return False
ok, ng = 0, N // 2 + 1
while ng - ok > 1:
mid = (ok + ng) // 2
if check(mid):
ok = mid
else:
ng = mid
print(ok)
if __name__ == '__main__':
ABC131E()
|
import sys
# input関係の定義
sys.setrecursionlimit(200000)
input = sys.stdin.readline
def ii(): return int(input())
def mi(): return map(int, input().rstrip().split())
def lmi(): return list(map(int, input().rstrip().split()))
def fi(): return float(input())
def mfi(): return map(float, input().rstrip().split())
def lmfi(): return list(map(float, input().rstrip().split()))
def li(): return list(input().rstrip())
def debug(*args, sep=" ", end="\n"): print("debug:", *args, file=sys.stderr, sep=sep, end=end) if not __debug__ else None
def exit(*arg): print(*arg); sys.exit()
# template
# BEGIN CUT HERE
class RollingHash():
BASE1 = 1007
BASE2 = 2009
MOD1 = 1000000007
MOD2 = 1000000009
def __init__(self, s, opt=2):
self.n = len(s)
self.opt = opt
self.hash1 = [0] * (self.n + 1)
self.power1 = [1] * (self.n + 1)
if opt == 2:
self.hash2 = [0] * (self.n + 1)
self.power2 = [1] * (self.n + 1)
for i, e in enumerate(s):
self.hash1[i + 1] = (self.hash1[i] * self.__class__.BASE1 + ord(e)) % self.__class__.MOD1
self.power1[i + 1] = (self.power1[i] * self.__class__.BASE1) % self.__class__.MOD1
if opt == 2:
self.hash2[i + 1] = (self.hash2[i] * self.__class__.BASE2 + ord(e)) % self.__class__.MOD2
self.power2[i + 1] = (self.power2[i] * self.__class__.BASE2) % self.__class__.MOD2
def get(self, l: int, r: int):
res1 = self.hash1[r] - self.hash1[l] * self.power1[r - l] % self.__class__.MOD1
if(res1 < 0):
res1 += self.__class__.MOD1
if self.opt == 2:
res2 = self.hash2[r] - self.hash2[l] * self.power2[r - l] % self.__class__.MOD2
if(res2 < 0):
res2 += self.__class__.MOD2
return (res1, res2) if self.opt == 2 else res1
# END CUT HERE
# notypehinting
def ABC131E():
N = ii()
S = li()
rh = RollingHash(S, opt=1)
def check(n: int):
d = dict()
for i in range(N - n + 1):
p = rh.get(i, i + n)
if p in d.keys():
if(i - d[p] >= n):
return True
else:
d[p] = i
return False
ok, ng = 0, N // 2 + 1
while ng - ok > 1:
mid = (ok + ng) // 2
if check(mid):
ok = mid
else:
ng = mid
print(ok)
if __name__ == '__main__':
ABC131E()
| 72
| 76
| 2,382
| 2,530
|
import sys
from collections import defaultdict
# input関係の定義
sys.setrecursionlimit(200000)
input = sys.stdin.readline
def ii():
return int(input())
def mi():
return map(int, input().rstrip().split())
def lmi():
return list(map(int, input().rstrip().split()))
def fi():
return float(input())
def mfi():
return map(float, input().rstrip().split())
def lmfi():
return list(map(float, input().rstrip().split()))
def li():
return list(input().rstrip())
def debug(*args, sep=" ", end="\n"):
print("debug:", *args, file=sys.stderr, sep=sep, end=end) if not __debug__ else None
def exit(*arg):
print(*arg)
sys.exit()
# template
# BEGIN CUT HERE
class RollingHash:
BASE1 = 1007
BASE2 = 2009
MOD1 = 1000000007
MOD2 = 1000000009
def __init__(self, s):
self.n = len(s)
self.hash1 = [0] * (self.n + 1)
self.hash2 = [0] * (self.n + 1)
self.power1 = [1] * (self.n + 1)
self.power2 = [1] * (self.n + 1)
for i, e in enumerate(s):
self.hash1[i + 1] = (
self.hash1[i] * self.__class__.BASE1 + ord(e)
) % self.__class__.MOD1
self.hash2[i + 1] = (
self.hash2[i] * self.__class__.BASE2 + ord(e)
) % self.__class__.MOD2
self.power1[i + 1] = (
self.power1[i] * self.__class__.BASE1
) % self.__class__.MOD1
self.power2[i + 1] = (
self.power2[i] * self.__class__.BASE2
) % self.__class__.MOD2
def get(self, l: int, r: int):
res1 = self.hash1[r] - self.hash1[l] * self.power1[r - l] % self.__class__.MOD1
if res1 < 0:
res1 += self.__class__.MOD1
res2 = self.hash2[r] - self.hash2[l] * self.power2[r - l] % self.__class__.MOD2
if res2 < 0:
res2 += self.__class__.MOD2
return (res1, res2)
# END CUT HERE
def ABC131E():
N = ii()
S = li()
rh = RollingHash(S)
def check(n: int):
d = dict()
for i in range(N - n + 1):
p = rh.get(i, i + n)
if p in d.keys():
if i - d[p] >= n:
return True
else:
d[p] = i
return False
ok, ng = 0, N // 2 + 1
while ng - ok > 1:
mid = (ok + ng) // 2
if check(mid):
ok = mid
else:
ng = mid
print(ok)
if __name__ == "__main__":
ABC131E()
|
import sys
# input関係の定義
sys.setrecursionlimit(200000)
input = sys.stdin.readline
def ii():
return int(input())
def mi():
return map(int, input().rstrip().split())
def lmi():
return list(map(int, input().rstrip().split()))
def fi():
return float(input())
def mfi():
return map(float, input().rstrip().split())
def lmfi():
return list(map(float, input().rstrip().split()))
def li():
return list(input().rstrip())
def debug(*args, sep=" ", end="\n"):
print("debug:", *args, file=sys.stderr, sep=sep, end=end) if not __debug__ else None
def exit(*arg):
print(*arg)
sys.exit()
# template
# BEGIN CUT HERE
class RollingHash:
BASE1 = 1007
BASE2 = 2009
MOD1 = 1000000007
MOD2 = 1000000009
def __init__(self, s, opt=2):
self.n = len(s)
self.opt = opt
self.hash1 = [0] * (self.n + 1)
self.power1 = [1] * (self.n + 1)
if opt == 2:
self.hash2 = [0] * (self.n + 1)
self.power2 = [1] * (self.n + 1)
for i, e in enumerate(s):
self.hash1[i + 1] = (
self.hash1[i] * self.__class__.BASE1 + ord(e)
) % self.__class__.MOD1
self.power1[i + 1] = (
self.power1[i] * self.__class__.BASE1
) % self.__class__.MOD1
if opt == 2:
self.hash2[i + 1] = (
self.hash2[i] * self.__class__.BASE2 + ord(e)
) % self.__class__.MOD2
self.power2[i + 1] = (
self.power2[i] * self.__class__.BASE2
) % self.__class__.MOD2
def get(self, l: int, r: int):
res1 = self.hash1[r] - self.hash1[l] * self.power1[r - l] % self.__class__.MOD1
if res1 < 0:
res1 += self.__class__.MOD1
if self.opt == 2:
res2 = (
self.hash2[r] - self.hash2[l] * self.power2[r - l] % self.__class__.MOD2
)
if res2 < 0:
res2 += self.__class__.MOD2
return (res1, res2) if self.opt == 2 else res1
# END CUT HERE
# notypehinting
def ABC131E():
N = ii()
S = li()
rh = RollingHash(S, opt=1)
def check(n: int):
d = dict()
for i in range(N - n + 1):
p = rh.get(i, i + n)
if p in d.keys():
if i - d[p] >= n:
return True
else:
d[p] = i
return False
ok, ng = 0, N // 2 + 1
while ng - ok > 1:
mid = (ok + ng) // 2
if check(mid):
ok = mid
else:
ng = mid
print(ok)
if __name__ == "__main__":
ABC131E()
| false
| 5.263158
|
[
"-from collections import defaultdict",
"- def __init__(self, s):",
"+ def __init__(self, s, opt=2):",
"+ self.opt = opt",
"- self.hash2 = [0] * (self.n + 1)",
"- self.power2 = [1] * (self.n + 1)",
"+ if opt == 2:",
"+ self.hash2 = [0] * (self.n + 1)",
"+ self.power2 = [1] * (self.n + 1)",
"- self.hash2[i + 1] = (",
"- self.hash2[i] * self.__class__.BASE2 + ord(e)",
"- ) % self.__class__.MOD2",
"- self.power2[i + 1] = (",
"- self.power2[i] * self.__class__.BASE2",
"- ) % self.__class__.MOD2",
"+ if opt == 2:",
"+ self.hash2[i + 1] = (",
"+ self.hash2[i] * self.__class__.BASE2 + ord(e)",
"+ ) % self.__class__.MOD2",
"+ self.power2[i + 1] = (",
"+ self.power2[i] * self.__class__.BASE2",
"+ ) % self.__class__.MOD2",
"- res2 = self.hash2[r] - self.hash2[l] * self.power2[r - l] % self.__class__.MOD2",
"- if res2 < 0:",
"- res2 += self.__class__.MOD2",
"- return (res1, res2)",
"+ if self.opt == 2:",
"+ res2 = (",
"+ self.hash2[r] - self.hash2[l] * self.power2[r - l] % self.__class__.MOD2",
"+ )",
"+ if res2 < 0:",
"+ res2 += self.__class__.MOD2",
"+ return (res1, res2) if self.opt == 2 else res1",
"+# notypehinting",
"- rh = RollingHash(S)",
"+ rh = RollingHash(S, opt=1)"
] | false
| 0.083341
| 0.087256
| 0.955133
|
[
"s069648551",
"s130074679"
] |
u644516473
|
p03475
|
python
|
s210875631
|
s003131184
| 77
| 71
| 3,188
| 3,188
|
Accepted
|
Accepted
| 7.79
|
import sys
readline = sys.stdin.readline
N = int(readline())
CSF = []
for i in range(N-1):
CSF.append(tuple(map(int, readline().split())))
for i in range(N):
time = 0
for c, s, f in CSF[i:N-1]:
if time < s:
time = s
else:
time = (time+f-1)//f*f
time += c
print(time)
|
import sys
readline = sys.stdin.readline
N = int(readline())
CSF = [tuple(map(int, readline().split())) for _ in range(N-1)]
for i in range(N):
time = 0
for c, s, f in CSF[i:N-1]:
if time < s:
time = s
else:
time = (time+f-1)//f*f
time += c
print(time)
| 16
| 14
| 347
| 327
|
import sys
readline = sys.stdin.readline
N = int(readline())
CSF = []
for i in range(N - 1):
CSF.append(tuple(map(int, readline().split())))
for i in range(N):
time = 0
for c, s, f in CSF[i : N - 1]:
if time < s:
time = s
else:
time = (time + f - 1) // f * f
time += c
print(time)
|
import sys
readline = sys.stdin.readline
N = int(readline())
CSF = [tuple(map(int, readline().split())) for _ in range(N - 1)]
for i in range(N):
time = 0
for c, s, f in CSF[i : N - 1]:
if time < s:
time = s
else:
time = (time + f - 1) // f * f
time += c
print(time)
| false
| 12.5
|
[
"-CSF = []",
"-for i in range(N - 1):",
"- CSF.append(tuple(map(int, readline().split())))",
"+CSF = [tuple(map(int, readline().split())) for _ in range(N - 1)]"
] | false
| 0.038326
| 0.038769
| 0.988572
|
[
"s210875631",
"s003131184"
] |
u226849101
|
p02693
|
python
|
s731371097
|
s363688900
| 25
| 21
| 9,172
| 9,104
|
Accepted
|
Accepted
| 16
|
K=int(eval(input()))
A,B=list(map(int,input().split()))
flag = False
for i in range(A,B+1):
if i%K==0:
flag=True
break
if flag:
print("OK")
else:
print("NG")
|
k =int(eval(input()))
a , b=list(map(int,input().split()))
flag = False
if b-a >= k:
flag=True
else:
for i in range(a,b+1):
if i%k==0:
flag=True
if flag :
print("OK")
else:
print("NG")
| 13
| 16
| 187
| 218
|
K = int(eval(input()))
A, B = list(map(int, input().split()))
flag = False
for i in range(A, B + 1):
if i % K == 0:
flag = True
break
if flag:
print("OK")
else:
print("NG")
|
k = int(eval(input()))
a, b = list(map(int, input().split()))
flag = False
if b - a >= k:
flag = True
else:
for i in range(a, b + 1):
if i % k == 0:
flag = True
if flag:
print("OK")
else:
print("NG")
| false
| 18.75
|
[
"-K = int(eval(input()))",
"-A, B = list(map(int, input().split()))",
"+k = int(eval(input()))",
"+a, b = list(map(int, input().split()))",
"-for i in range(A, B + 1):",
"- if i % K == 0:",
"- flag = True",
"- break",
"+if b - a >= k:",
"+ flag = True",
"+else:",
"+ for i in range(a, b + 1):",
"+ if i % k == 0:",
"+ flag = True"
] | false
| 0.065491
| 0.036174
| 1.81045
|
[
"s731371097",
"s363688900"
] |
u200887663
|
p03325
|
python
|
s183370603
|
s438176673
| 62
| 52
| 4,212
| 10,064
|
Accepted
|
Accepted
| 16.13
|
n=int(eval(input()))
#a,b,n=map(int,input().split())
al=list(map(int,input().split()))
#l=[list(map(int,input().split())) for i in range(n)]
def div2(v):
res=0
if v==0:
return res
while v%2==0:
v=v//2
res+=1
return res
ans=0
for ai in al:
ans+=div2(ai)
print(ans)
|
n = int(eval(input()))
#n, W = map(int, input().split())
al = list(map(int, input().split()))
#al=[list(input()) for i in range(n)]
def div2(v, a):
res = 0
if v == 0:
return res
while v % a == 0:
v = v//a
res += 1
return res
ans = 0
for a in al:
ans += div2(a, 2)
print(ans)
| 18
| 20
| 321
| 336
|
n = int(eval(input()))
# a,b,n=map(int,input().split())
al = list(map(int, input().split()))
# l=[list(map(int,input().split())) for i in range(n)]
def div2(v):
res = 0
if v == 0:
return res
while v % 2 == 0:
v = v // 2
res += 1
return res
ans = 0
for ai in al:
ans += div2(ai)
print(ans)
|
n = int(eval(input()))
# n, W = map(int, input().split())
al = list(map(int, input().split()))
# al=[list(input()) for i in range(n)]
def div2(v, a):
res = 0
if v == 0:
return res
while v % a == 0:
v = v // a
res += 1
return res
ans = 0
for a in al:
ans += div2(a, 2)
print(ans)
| false
| 10
|
[
"-# a,b,n=map(int,input().split())",
"+# n, W = map(int, input().split())",
"-# l=[list(map(int,input().split())) for i in range(n)]",
"-def div2(v):",
"+# al=[list(input()) for i in range(n)]",
"+def div2(v, a):",
"- while v % 2 == 0:",
"- v = v // 2",
"+ while v % a == 0:",
"+ v = v // a",
"-for ai in al:",
"- ans += div2(ai)",
"+for a in al:",
"+ ans += div2(a, 2)"
] | false
| 0.036402
| 0.04255
| 0.855528
|
[
"s183370603",
"s438176673"
] |
u475503988
|
p02973
|
python
|
s514654530
|
s186748549
| 525
| 411
| 8,188
| 8,060
|
Accepted
|
Accepted
| 21.71
|
from collections import deque
import bisect
N = int(eval(input()))
A = [int(eval(input())) for _ in range(N)]
d = deque()
for i in range(N):
p = bisect.bisect_left(d, A[i])
if p==0:
d.appendleft(A[i])
else:
d[p-1] = A[i]
ans = len(d)
print(ans)
|
import sys
input = sys.stdin.readline
from collections import deque
import bisect
N = int(eval(input()))
A = [int(eval(input())) for _ in range(N)]
d = deque()
for i in range(N):
p = bisect.bisect_left(d, A[i])
if p==0:
d.appendleft(A[i])
else:
d[p-1] = A[i]
ans = len(d)
print(ans)
| 15
| 17
| 277
| 317
|
from collections import deque
import bisect
N = int(eval(input()))
A = [int(eval(input())) for _ in range(N)]
d = deque()
for i in range(N):
p = bisect.bisect_left(d, A[i])
if p == 0:
d.appendleft(A[i])
else:
d[p - 1] = A[i]
ans = len(d)
print(ans)
|
import sys
input = sys.stdin.readline
from collections import deque
import bisect
N = int(eval(input()))
A = [int(eval(input())) for _ in range(N)]
d = deque()
for i in range(N):
p = bisect.bisect_left(d, A[i])
if p == 0:
d.appendleft(A[i])
else:
d[p - 1] = A[i]
ans = len(d)
print(ans)
| false
| 11.764706
|
[
"+import sys",
"+",
"+input = sys.stdin.readline"
] | false
| 0.03827
| 0.040143
| 0.953347
|
[
"s514654530",
"s186748549"
] |
u562935282
|
p03372
|
python
|
s212142781
|
s098191107
| 669
| 469
| 37,576
| 33,608
|
Accepted
|
Accepted
| 29.9
|
def main():
from collections import namedtuple
Dish = namedtuple('Dish', 'idx x v')
n, c = list(map(int, input().split()))
ds = []
for i in range(n):
x, v = list(map(int, input().split()))
ds.append(Dish(idx=i, x=x, v=v))
gol = [0] * n # 時計回りの最大値
s = 0
ma = 0
for d in ds:
s += d.v
ma = max(ma, s - d.x)
gol[d.idx] = ma
gor = [0] * n # 反時計回りの最大値
s = 0
ma = 0
for d in reversed(ds):
s += d.v
ma = max(ma, s - (c - d.x))
gor[d.idx] = ma
gol0 = [0] * n # 時計回りから0に戻ったときのカロリー
for d in reversed(ds):
gol0[d.idx] = gol[d.idx] - d.x
gor0 = [0] * n # 反時計回りから0に戻ったときのカロリー
for d in reversed(ds):
gor0[d.idx] = gor[d.idx] - (c - d.x)
ret = max(max(gol), max(gor))
for l in range(n - 1):
t = gol0[l] + gor[l + 1]
ret = max(ret, t)
for r in range(n - 1, 0, -1):
t = gor0[r] + gol[r - 1]
ret = max(ret, t)
print(ret)
if __name__ == '__main__':
main()
|
def main():
from collections import namedtuple
import sys
input = sys.stdin.readline
Sushi = namedtuple('Sushi', 'x cal')
n, c = list(map(int, input().split()))
a = []
for _ in range(n):
x, v = list(map(int, input().split()))
a.append(Sushi(x=x, cal=v))
# x昇順ソート済
clock = [0] * (n + 1) # 注目する寿司以前で離脱する最大摂取カロリー
clock_to_0 = [0] * (n + 1) # 時計回り->初期位置
ma = 0 # 注目する寿司以前で離脱する最大摂取カロリー
curr = 0 # 現在のカロリー(移動によるカロリー消費を無視)
for i, s in enumerate(a, start=1):
curr += s.cal
ma = max(ma, curr - s.x)
clock[i] = ma
clock_to_0[i] = curr - s.x * 2
anti = [0] * (n + 1) # 注目する寿司以前で離脱する最大摂取カロリー
anti_to_0 = [0] * (n + 1) # 反時計回り->初期位置
ma = 0 # 注目する寿司以前で離脱する最大摂取カロリー
curr = 0 # 現在のカロリー(移動によるカロリー消費を無視)
for i, s in zip(list(range(n, -1, -1)), reversed(a)):
curr += s.cal
ma = max(ma, curr - (c - s.x))
anti[i] = ma
anti_to_0[i] = curr - (c - s.x) * 2
ans = 0
for exit_pos in range(1, n + 1):
ans = max(
ans,
clock_to_0[exit_pos - 1] + anti[exit_pos],
anti_to_0[(exit_pos + 1) % (n + 1)] + clock[exit_pos]
)
print(ans)
if __name__ == '__main__':
main()
| 50
| 48
| 1,089
| 1,301
|
def main():
from collections import namedtuple
Dish = namedtuple("Dish", "idx x v")
n, c = list(map(int, input().split()))
ds = []
for i in range(n):
x, v = list(map(int, input().split()))
ds.append(Dish(idx=i, x=x, v=v))
gol = [0] * n # 時計回りの最大値
s = 0
ma = 0
for d in ds:
s += d.v
ma = max(ma, s - d.x)
gol[d.idx] = ma
gor = [0] * n # 反時計回りの最大値
s = 0
ma = 0
for d in reversed(ds):
s += d.v
ma = max(ma, s - (c - d.x))
gor[d.idx] = ma
gol0 = [0] * n # 時計回りから0に戻ったときのカロリー
for d in reversed(ds):
gol0[d.idx] = gol[d.idx] - d.x
gor0 = [0] * n # 反時計回りから0に戻ったときのカロリー
for d in reversed(ds):
gor0[d.idx] = gor[d.idx] - (c - d.x)
ret = max(max(gol), max(gor))
for l in range(n - 1):
t = gol0[l] + gor[l + 1]
ret = max(ret, t)
for r in range(n - 1, 0, -1):
t = gor0[r] + gol[r - 1]
ret = max(ret, t)
print(ret)
if __name__ == "__main__":
main()
|
def main():
from collections import namedtuple
import sys
input = sys.stdin.readline
Sushi = namedtuple("Sushi", "x cal")
n, c = list(map(int, input().split()))
a = []
for _ in range(n):
x, v = list(map(int, input().split()))
a.append(Sushi(x=x, cal=v))
# x昇順ソート済
clock = [0] * (n + 1) # 注目する寿司以前で離脱する最大摂取カロリー
clock_to_0 = [0] * (n + 1) # 時計回り->初期位置
ma = 0 # 注目する寿司以前で離脱する最大摂取カロリー
curr = 0 # 現在のカロリー(移動によるカロリー消費を無視)
for i, s in enumerate(a, start=1):
curr += s.cal
ma = max(ma, curr - s.x)
clock[i] = ma
clock_to_0[i] = curr - s.x * 2
anti = [0] * (n + 1) # 注目する寿司以前で離脱する最大摂取カロリー
anti_to_0 = [0] * (n + 1) # 反時計回り->初期位置
ma = 0 # 注目する寿司以前で離脱する最大摂取カロリー
curr = 0 # 現在のカロリー(移動によるカロリー消費を無視)
for i, s in zip(list(range(n, -1, -1)), reversed(a)):
curr += s.cal
ma = max(ma, curr - (c - s.x))
anti[i] = ma
anti_to_0[i] = curr - (c - s.x) * 2
ans = 0
for exit_pos in range(1, n + 1):
ans = max(
ans,
clock_to_0[exit_pos - 1] + anti[exit_pos],
anti_to_0[(exit_pos + 1) % (n + 1)] + clock[exit_pos],
)
print(ans)
if __name__ == "__main__":
main()
| false
| 4
|
[
"+ import sys",
"- Dish = namedtuple(\"Dish\", \"idx x v\")",
"+ input = sys.stdin.readline",
"+ Sushi = namedtuple(\"Sushi\", \"x cal\")",
"- ds = []",
"- for i in range(n):",
"+ a = []",
"+ for _ in range(n):",
"- ds.append(Dish(idx=i, x=x, v=v))",
"- gol = [0] * n # 時計回りの最大値",
"- s = 0",
"- ma = 0",
"- for d in ds:",
"- s += d.v",
"- ma = max(ma, s - d.x)",
"- gol[d.idx] = ma",
"- gor = [0] * n # 反時計回りの最大値",
"- s = 0",
"- ma = 0",
"- for d in reversed(ds):",
"- s += d.v",
"- ma = max(ma, s - (c - d.x))",
"- gor[d.idx] = ma",
"- gol0 = [0] * n # 時計回りから0に戻ったときのカロリー",
"- for d in reversed(ds):",
"- gol0[d.idx] = gol[d.idx] - d.x",
"- gor0 = [0] * n # 反時計回りから0に戻ったときのカロリー",
"- for d in reversed(ds):",
"- gor0[d.idx] = gor[d.idx] - (c - d.x)",
"- ret = max(max(gol), max(gor))",
"- for l in range(n - 1):",
"- t = gol0[l] + gor[l + 1]",
"- ret = max(ret, t)",
"- for r in range(n - 1, 0, -1):",
"- t = gor0[r] + gol[r - 1]",
"- ret = max(ret, t)",
"- print(ret)",
"+ a.append(Sushi(x=x, cal=v))",
"+ # x昇順ソート済",
"+ clock = [0] * (n + 1) # 注目する寿司以前で離脱する最大摂取カロリー",
"+ clock_to_0 = [0] * (n + 1) # 時計回り->初期位置",
"+ ma = 0 # 注目する寿司以前で離脱する最大摂取カロリー",
"+ curr = 0 # 現在のカロリー(移動によるカロリー消費を無視)",
"+ for i, s in enumerate(a, start=1):",
"+ curr += s.cal",
"+ ma = max(ma, curr - s.x)",
"+ clock[i] = ma",
"+ clock_to_0[i] = curr - s.x * 2",
"+ anti = [0] * (n + 1) # 注目する寿司以前で離脱する最大摂取カロリー",
"+ anti_to_0 = [0] * (n + 1) # 反時計回り->初期位置",
"+ ma = 0 # 注目する寿司以前で離脱する最大摂取カロリー",
"+ curr = 0 # 現在のカロリー(移動によるカロリー消費を無視)",
"+ for i, s in zip(list(range(n, -1, -1)), reversed(a)):",
"+ curr += s.cal",
"+ ma = max(ma, curr - (c - s.x))",
"+ anti[i] = ma",
"+ anti_to_0[i] = curr - (c - s.x) * 2",
"+ ans = 0",
"+ for exit_pos in range(1, n + 1):",
"+ ans = max(",
"+ ans,",
"+ clock_to_0[exit_pos - 1] + anti[exit_pos],",
"+ anti_to_0[(exit_pos + 1) % (n + 1)] + clock[exit_pos],",
"+ )",
"+ print(ans)"
] | false
| 0.159069
| 0.162125
| 0.981152
|
[
"s212142781",
"s098191107"
] |
u581187895
|
p03633
|
python
|
s590015278
|
s906035213
| 35
| 17
| 5,128
| 3,060
|
Accepted
|
Accepted
| 51.43
|
from functools import reduce
from fractions import gcd
n = int(eval(input()))
arr = [int(eval(input())) for i in range(n)]
def lcm(x, y):
return (x*y)//gcd(x,y)
def lcmm(l):
return reduce(lcm, l)
print((lcmm(arr)))
|
def gcd(a, b):
while b:
a, b = b, a%b
return a
def lcm(a, b):
return a*b // gcd(a, b)
N = int(eval(input()))
T = [int(eval(input())) for _ in range(N)]
ans = 1
for t in T:
ans = lcm(ans, t)
print(ans)
| 13
| 17
| 221
| 226
|
from functools import reduce
from fractions import gcd
n = int(eval(input()))
arr = [int(eval(input())) for i in range(n)]
def lcm(x, y):
return (x * y) // gcd(x, y)
def lcmm(l):
return reduce(lcm, l)
print((lcmm(arr)))
|
def gcd(a, b):
while b:
a, b = b, a % b
return a
def lcm(a, b):
return a * b // gcd(a, b)
N = int(eval(input()))
T = [int(eval(input())) for _ in range(N)]
ans = 1
for t in T:
ans = lcm(ans, t)
print(ans)
| false
| 23.529412
|
[
"-from functools import reduce",
"-from fractions import gcd",
"-",
"-n = int(eval(input()))",
"-arr = [int(eval(input())) for i in range(n)]",
"+def gcd(a, b):",
"+ while b:",
"+ a, b = b, a % b",
"+ return a",
"-def lcm(x, y):",
"- return (x * y) // gcd(x, y)",
"+def lcm(a, b):",
"+ return a * b // gcd(a, b)",
"-def lcmm(l):",
"- return reduce(lcm, l)",
"-",
"-",
"-print((lcmm(arr)))",
"+N = int(eval(input()))",
"+T = [int(eval(input())) for _ in range(N)]",
"+ans = 1",
"+for t in T:",
"+ ans = lcm(ans, t)",
"+print(ans)"
] | false
| 0.093674
| 0.125877
| 0.74417
|
[
"s590015278",
"s906035213"
] |
u513081876
|
p03435
|
python
|
s440927259
|
s422920670
| 149
| 18
| 14,428
| 3,064
|
Accepted
|
Accepted
| 87.92
|
import numpy as np
c = [[], [], []]
for i in range(3):
c[i] = list(map(int, input().split()))
d = np.array(c)
if len(set(d[1]-d[0])) == 1 and len(set(d[2]-d[0])) == 1:
print('Yes')
else:
print('No')
|
c = [[int(i) for i in input().split()] for i in range(3)]
for a1 in range(101):
b1 = c[0][0] - a1
b2 = c[0][1] - a1
b3 = c[0][2] - a1
if 0 <= b1 <= 100 or 0 <= b2 <= 100 or 0 <= b3 <= 100:
if c[1][0] - b1 == c[1][1] - b2 == c[1][2] -b3 and 0<=c[1][0] <= 100 and c[2][0] - b1 == c[2][1] - b2 == c[2][2] -b3 and 0<=c[2][0] <= 100:
print('Yes')
break
else:
print('No')
| 11
| 12
| 222
| 429
|
import numpy as np
c = [[], [], []]
for i in range(3):
c[i] = list(map(int, input().split()))
d = np.array(c)
if len(set(d[1] - d[0])) == 1 and len(set(d[2] - d[0])) == 1:
print("Yes")
else:
print("No")
|
c = [[int(i) for i in input().split()] for i in range(3)]
for a1 in range(101):
b1 = c[0][0] - a1
b2 = c[0][1] - a1
b3 = c[0][2] - a1
if 0 <= b1 <= 100 or 0 <= b2 <= 100 or 0 <= b3 <= 100:
if (
c[1][0] - b1 == c[1][1] - b2 == c[1][2] - b3
and 0 <= c[1][0] <= 100
and c[2][0] - b1 == c[2][1] - b2 == c[2][2] - b3
and 0 <= c[2][0] <= 100
):
print("Yes")
break
else:
print("No")
| false
| 8.333333
|
[
"-import numpy as np",
"-",
"-c = [[], [], []]",
"-for i in range(3):",
"- c[i] = list(map(int, input().split()))",
"-d = np.array(c)",
"-if len(set(d[1] - d[0])) == 1 and len(set(d[2] - d[0])) == 1:",
"- print(\"Yes\")",
"+c = [[int(i) for i in input().split()] for i in range(3)]",
"+for a1 in range(101):",
"+ b1 = c[0][0] - a1",
"+ b2 = c[0][1] - a1",
"+ b3 = c[0][2] - a1",
"+ if 0 <= b1 <= 100 or 0 <= b2 <= 100 or 0 <= b3 <= 100:",
"+ if (",
"+ c[1][0] - b1 == c[1][1] - b2 == c[1][2] - b3",
"+ and 0 <= c[1][0] <= 100",
"+ and c[2][0] - b1 == c[2][1] - b2 == c[2][2] - b3",
"+ and 0 <= c[2][0] <= 100",
"+ ):",
"+ print(\"Yes\")",
"+ break"
] | false
| 0.695923
| 0.03663
| 18.998491
|
[
"s440927259",
"s422920670"
] |
u223904637
|
p02845
|
python
|
s690888878
|
s339653457
| 245
| 161
| 53,996
| 20,572
|
Accepted
|
Accepted
| 34.29
|
n=int(eval(input()))
l=list(map(int,input().split()))
mod=10**9+7
ans=1
rgb=[0]*3
for i in range(n):
f=0
for j in range(3):
if l[i]==rgb[j]:
if f==0:
rgb[j]+=1
f+=1
ans*=f
ans%=mod
print(ans)
|
mod=10**9+7
n=int(eval(input()))
l=list(map(int,input().split()))
ans=1
rgb=[0,0,0]
for i in range(n):
c=0
for j in range(3):
if l[i]==rgb[j]:
c+=1
if c==0:
print((0))
exit()
p=rgb.index(l[i])
if not 0<=p<=2:
print((0))
exit()
rgb[p]+=1
ans*=c
ans%=mod
print(ans)
| 15
| 21
| 263
| 358
|
n = int(eval(input()))
l = list(map(int, input().split()))
mod = 10**9 + 7
ans = 1
rgb = [0] * 3
for i in range(n):
f = 0
for j in range(3):
if l[i] == rgb[j]:
if f == 0:
rgb[j] += 1
f += 1
ans *= f
ans %= mod
print(ans)
|
mod = 10**9 + 7
n = int(eval(input()))
l = list(map(int, input().split()))
ans = 1
rgb = [0, 0, 0]
for i in range(n):
c = 0
for j in range(3):
if l[i] == rgb[j]:
c += 1
if c == 0:
print((0))
exit()
p = rgb.index(l[i])
if not 0 <= p <= 2:
print((0))
exit()
rgb[p] += 1
ans *= c
ans %= mod
print(ans)
| false
| 28.571429
|
[
"+mod = 10**9 + 7",
"-mod = 10**9 + 7",
"-rgb = [0] * 3",
"+rgb = [0, 0, 0]",
"- f = 0",
"+ c = 0",
"- if f == 0:",
"- rgb[j] += 1",
"- f += 1",
"- ans *= f",
"+ c += 1",
"+ if c == 0:",
"+ print((0))",
"+ exit()",
"+ p = rgb.index(l[i])",
"+ if not 0 <= p <= 2:",
"+ print((0))",
"+ exit()",
"+ rgb[p] += 1",
"+ ans *= c"
] | false
| 0.045552
| 0.042646
| 1.068139
|
[
"s690888878",
"s339653457"
] |
u813450984
|
p03331
|
python
|
s488297221
|
s885715716
| 1,263
| 179
| 3,060
| 3,060
|
Accepted
|
Accepted
| 85.83
|
n = int(eval(input()))
ans = float('Inf')
for i in range(1, n):
if i > n//2:
break
if eval('+'.join(str(i))) + eval('+'.join(str(n - i))) < ans:
ans = eval('+'.join(str(i))) + eval('+'.join(str(n - i)))
print(ans)
|
n = int(eval(input()))
ans = float('Inf')
for i in range(1, n//2+1):
if sum(list(map(int, str(i)))) + sum(list(map(int, str(n - i)))) < ans:
ans = sum(list(map(int, str(i)))) + sum(list(map(int, str(n - i))))
print(ans)
| 8
| 6
| 226
| 224
|
n = int(eval(input()))
ans = float("Inf")
for i in range(1, n):
if i > n // 2:
break
if eval("+".join(str(i))) + eval("+".join(str(n - i))) < ans:
ans = eval("+".join(str(i))) + eval("+".join(str(n - i)))
print(ans)
|
n = int(eval(input()))
ans = float("Inf")
for i in range(1, n // 2 + 1):
if sum(list(map(int, str(i)))) + sum(list(map(int, str(n - i)))) < ans:
ans = sum(list(map(int, str(i)))) + sum(list(map(int, str(n - i))))
print(ans)
| false
| 25
|
[
"-for i in range(1, n):",
"- if i > n // 2:",
"- break",
"- if eval(\"+\".join(str(i))) + eval(\"+\".join(str(n - i))) < ans:",
"- ans = eval(\"+\".join(str(i))) + eval(\"+\".join(str(n - i)))",
"+for i in range(1, n // 2 + 1):",
"+ if sum(list(map(int, str(i)))) + sum(list(map(int, str(n - i)))) < ans:",
"+ ans = sum(list(map(int, str(i)))) + sum(list(map(int, str(n - i))))"
] | false
| 0.445283
| 0.058231
| 7.646839
|
[
"s488297221",
"s885715716"
] |
u918601425
|
p03137
|
python
|
s141960852
|
s951275649
| 122
| 103
| 13,840
| 13,832
|
Accepted
|
Accepted
| 15.57
|
N,M= [int(s) for s in input().split()]
lst = [int(s) for s in input().split()]
lst.sort()
gap=[]
for i in range(1,M):
gap.append(lst[i]-lst[i-1])
gap.sort()
ans=0
for i in range(M-N):
ans+=gap[i]
print(ans)
|
N,M=[int(s) for s in input().split()]
if N>=M:
print((0))
else:
ls=[int(s) for s in input().split()]
ls.sort()
d=[ls[i+1]-ls[i] for i in range(M-1)]
d.sort()
print((sum(d[:M-N])))
| 11
| 9
| 220
| 195
|
N, M = [int(s) for s in input().split()]
lst = [int(s) for s in input().split()]
lst.sort()
gap = []
for i in range(1, M):
gap.append(lst[i] - lst[i - 1])
gap.sort()
ans = 0
for i in range(M - N):
ans += gap[i]
print(ans)
|
N, M = [int(s) for s in input().split()]
if N >= M:
print((0))
else:
ls = [int(s) for s in input().split()]
ls.sort()
d = [ls[i + 1] - ls[i] for i in range(M - 1)]
d.sort()
print((sum(d[: M - N])))
| false
| 18.181818
|
[
"-lst = [int(s) for s in input().split()]",
"-lst.sort()",
"-gap = []",
"-for i in range(1, M):",
"- gap.append(lst[i] - lst[i - 1])",
"-gap.sort()",
"-ans = 0",
"-for i in range(M - N):",
"- ans += gap[i]",
"-print(ans)",
"+if N >= M:",
"+ print((0))",
"+else:",
"+ ls = [int(s) for s in input().split()]",
"+ ls.sort()",
"+ d = [ls[i + 1] - ls[i] for i in range(M - 1)]",
"+ d.sort()",
"+ print((sum(d[: M - N])))"
] | false
| 0.044233
| 0.044452
| 0.995073
|
[
"s141960852",
"s951275649"
] |
u332906195
|
p03212
|
python
|
s184703481
|
s824452436
| 128
| 37
| 3,064
| 3,316
|
Accepted
|
Accepted
| 71.09
|
# -*- coding: utf-8 -*-
N = int(eval(input()))
ans = 0
cursor = "357"
def increment(cursor):
l = len(cursor)
ret = [''] * (l + 1)
if cursor[-1] == '7':
ret[-1] = '3'
ret[-2] = '3'
elif cursor[-1] == '5':
ret[-1] = '7'
elif cursor[-1] == '3':
ret[-1] = '5'
for i in range(l-1):
if ret[-(2 + i)] == '3':
if cursor[-(2 + i)] == '7':
ret[-(2 + i)] = '3'
ret[-(3 + i)] = '3'
elif cursor[-(2 + i)] == '5':
ret[-(2 + i)] = '7'
elif cursor[-(2 + i)] == '3':
ret[-(2 + i)] = '5'
else:
ret[-(2 + i)] = cursor[-(2 + i)]
return ''.join(ret)
while N >= int(cursor):
if '7' in cursor and '5' in cursor and '3' in cursor:
ans += 1
cursor = increment(cursor)
print(ans)
|
from itertools import product
N = int(eval(input()))
ans, L = 0, len(str(N))
for i in range(L + 1):
for p in product(("7", "5", "3"), repeat=i):
if "7" in p and "5" in p and "3" in p:
if (i == L and int(''.join(p)) <= N) or i < L:
ans += 1
print(ans)
| 40
| 10
| 900
| 295
|
# -*- coding: utf-8 -*-
N = int(eval(input()))
ans = 0
cursor = "357"
def increment(cursor):
l = len(cursor)
ret = [""] * (l + 1)
if cursor[-1] == "7":
ret[-1] = "3"
ret[-2] = "3"
elif cursor[-1] == "5":
ret[-1] = "7"
elif cursor[-1] == "3":
ret[-1] = "5"
for i in range(l - 1):
if ret[-(2 + i)] == "3":
if cursor[-(2 + i)] == "7":
ret[-(2 + i)] = "3"
ret[-(3 + i)] = "3"
elif cursor[-(2 + i)] == "5":
ret[-(2 + i)] = "7"
elif cursor[-(2 + i)] == "3":
ret[-(2 + i)] = "5"
else:
ret[-(2 + i)] = cursor[-(2 + i)]
return "".join(ret)
while N >= int(cursor):
if "7" in cursor and "5" in cursor and "3" in cursor:
ans += 1
cursor = increment(cursor)
print(ans)
|
from itertools import product
N = int(eval(input()))
ans, L = 0, len(str(N))
for i in range(L + 1):
for p in product(("7", "5", "3"), repeat=i):
if "7" in p and "5" in p and "3" in p:
if (i == L and int("".join(p)) <= N) or i < L:
ans += 1
print(ans)
| false
| 75
|
[
"-# -*- coding: utf-8 -*-",
"+from itertools import product",
"+",
"-ans = 0",
"-cursor = \"357\"",
"-",
"-",
"-def increment(cursor):",
"- l = len(cursor)",
"- ret = [\"\"] * (l + 1)",
"- if cursor[-1] == \"7\":",
"- ret[-1] = \"3\"",
"- ret[-2] = \"3\"",
"- elif cursor[-1] == \"5\":",
"- ret[-1] = \"7\"",
"- elif cursor[-1] == \"3\":",
"- ret[-1] = \"5\"",
"- for i in range(l - 1):",
"- if ret[-(2 + i)] == \"3\":",
"- if cursor[-(2 + i)] == \"7\":",
"- ret[-(2 + i)] = \"3\"",
"- ret[-(3 + i)] = \"3\"",
"- elif cursor[-(2 + i)] == \"5\":",
"- ret[-(2 + i)] = \"7\"",
"- elif cursor[-(2 + i)] == \"3\":",
"- ret[-(2 + i)] = \"5\"",
"- else:",
"- ret[-(2 + i)] = cursor[-(2 + i)]",
"- return \"\".join(ret)",
"-",
"-",
"-while N >= int(cursor):",
"- if \"7\" in cursor and \"5\" in cursor and \"3\" in cursor:",
"- ans += 1",
"- cursor = increment(cursor)",
"+ans, L = 0, len(str(N))",
"+for i in range(L + 1):",
"+ for p in product((\"7\", \"5\", \"3\"), repeat=i):",
"+ if \"7\" in p and \"5\" in p and \"3\" in p:",
"+ if (i == L and int(\"\".join(p)) <= N) or i < L:",
"+ ans += 1"
] | false
| 0.050147
| 0.041042
| 1.221853
|
[
"s184703481",
"s824452436"
] |
u018679195
|
p03071
|
python
|
s049081598
|
s334844996
| 19
| 17
| 3,060
| 2,940
|
Accepted
|
Accepted
| 10.53
|
line = eval(input())
a, b = [int(n) for n in line.split()]
apb = a+b
aa = a+(a-1)
bb = b+(b-1)
print((max(apb, max(bb, aa))))
|
a = [int(x) for x in input().split()]
a.sort()
maior = 0
maior += a[-1]
a[-1] -= 1
a.sort()
maior += a[-1]
print(maior)
| 10
| 12
| 130
| 135
|
line = eval(input())
a, b = [int(n) for n in line.split()]
apb = a + b
aa = a + (a - 1)
bb = b + (b - 1)
print((max(apb, max(bb, aa))))
|
a = [int(x) for x in input().split()]
a.sort()
maior = 0
maior += a[-1]
a[-1] -= 1
a.sort()
maior += a[-1]
print(maior)
| false
| 16.666667
|
[
"-line = eval(input())",
"-a, b = [int(n) for n in line.split()]",
"-apb = a + b",
"-aa = a + (a - 1)",
"-bb = b + (b - 1)",
"-print((max(apb, max(bb, aa))))",
"+a = [int(x) for x in input().split()]",
"+a.sort()",
"+maior = 0",
"+maior += a[-1]",
"+a[-1] -= 1",
"+a.sort()",
"+maior += a[-1]",
"+print(maior)"
] | false
| 0.044656
| 0.044601
| 1.001235
|
[
"s049081598",
"s334844996"
] |
u596276291
|
p03813
|
python
|
s956356646
|
s104091292
| 32
| 27
| 3,316
| 3,952
|
Accepted
|
Accepted
| 15.62
|
from collections import defaultdict
def main():
print(("ABC" if int(eval(input())) < 1200 else "ARC"))
if __name__ == '__main__':
main()
|
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]
dy8, dx8 = [0, -1, 0, 1, 1, -1, -1, 1], [1, 0, -1, 0, 1, 1, -1, -1]
def inside(y, x, H, W):
return 0 <= y < H and 0 <= x < W
def ceil(a, b):
return (a + b - 1) // b
def main():
x = int(eval(input()))
if x < 1200:
print("ABC")
else:
print("ARC")
if __name__ == '__main__':
main()
| 9
| 33
| 149
| 813
|
from collections import defaultdict
def main():
print(("ABC" if int(eval(input())) < 1200 else "ARC"))
if __name__ == "__main__":
main()
|
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]
dy8, dx8 = [0, -1, 0, 1, 1, -1, -1, 1], [1, 0, -1, 0, 1, 1, -1, -1]
def inside(y, x, H, W):
return 0 <= y < H and 0 <= x < W
def ceil(a, b):
return (a + b - 1) // b
def main():
x = int(eval(input()))
if x < 1200:
print("ABC")
else:
print("ARC")
if __name__ == "__main__":
main()
| false
| 72.727273
|
[
"-from collections import defaultdict",
"+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]",
"+dy8, dx8 = [0, -1, 0, 1, 1, -1, -1, 1], [1, 0, -1, 0, 1, 1, -1, -1]",
"+",
"+",
"+def inside(y, x, H, W):",
"+ return 0 <= y < H and 0 <= x < W",
"+",
"+",
"+def ceil(a, b):",
"+ return (a + b - 1) // b",
"- print((\"ABC\" if int(eval(input())) < 1200 else \"ARC\"))",
"+ x = int(eval(input()))",
"+ if x < 1200:",
"+ print(\"ABC\")",
"+ else:",
"+ print(\"ARC\")"
] | false
| 0.052155
| 0.036902
| 1.41333
|
[
"s956356646",
"s104091292"
] |
u266014018
|
p02721
|
python
|
s537597021
|
s937496988
| 275
| 160
| 17,508
| 26,224
|
Accepted
|
Accepted
| 41.82
|
import sys
def yutori():
N, K, C = list(map(int,sys.stdin.readline().split()))
S = [i for i in sys.stdin.readline()]
l = [i+1 for i in range(N) if S[i] == 'o']
Left = []
Right = []
for u in l:
if Left == []:
Left.append(u)
if u > Left[-1] + C:
Left.append(u)
if len(Right) == K:
break
if len(Left) <K:
exit()
for u in l[::-1]:
if Right== []:
Right.append(u)
if u < Right[-1] - C:
Right.append(u)
if len(Right) == K:
break
if len(Right) <K:
exit()
for i in range(K):
if Left[i] == Right[-i-1]:
print((Left[i]))
yutori()
|
def main():
import sys
def input(): return sys.stdin.readline().rstrip()
n, k, c = list(map(int, input().split()))
s = [True if i == 'o' else False for i in eval(input())]
L = [0]*k
R = [0]*k
i = n-1
now = k-1
while 0 <= now:
if s[i]:
R[now] = i
i -= c
now -= 1
i -= 1
i = 0
now = 0
while now < k:
if s[i]:
L[now] = i
if L[now] == R[now]:
print((i+1))
i += c
now += 1
i += 1
if __name__ == '__main__':
main()
| 34
| 33
| 761
| 628
|
import sys
def yutori():
N, K, C = list(map(int, sys.stdin.readline().split()))
S = [i for i in sys.stdin.readline()]
l = [i + 1 for i in range(N) if S[i] == "o"]
Left = []
Right = []
for u in l:
if Left == []:
Left.append(u)
if u > Left[-1] + C:
Left.append(u)
if len(Right) == K:
break
if len(Left) < K:
exit()
for u in l[::-1]:
if Right == []:
Right.append(u)
if u < Right[-1] - C:
Right.append(u)
if len(Right) == K:
break
if len(Right) < K:
exit()
for i in range(K):
if Left[i] == Right[-i - 1]:
print((Left[i]))
yutori()
|
def main():
import sys
def input():
return sys.stdin.readline().rstrip()
n, k, c = list(map(int, input().split()))
s = [True if i == "o" else False for i in eval(input())]
L = [0] * k
R = [0] * k
i = n - 1
now = k - 1
while 0 <= now:
if s[i]:
R[now] = i
i -= c
now -= 1
i -= 1
i = 0
now = 0
while now < k:
if s[i]:
L[now] = i
if L[now] == R[now]:
print((i + 1))
i += c
now += 1
i += 1
if __name__ == "__main__":
main()
| false
| 2.941176
|
[
"-import sys",
"+def main():",
"+ import sys",
"+",
"+ def input():",
"+ return sys.stdin.readline().rstrip()",
"+",
"+ n, k, c = list(map(int, input().split()))",
"+ s = [True if i == \"o\" else False for i in eval(input())]",
"+ L = [0] * k",
"+ R = [0] * k",
"+ i = n - 1",
"+ now = k - 1",
"+ while 0 <= now:",
"+ if s[i]:",
"+ R[now] = i",
"+ i -= c",
"+ now -= 1",
"+ i -= 1",
"+ i = 0",
"+ now = 0",
"+ while now < k:",
"+ if s[i]:",
"+ L[now] = i",
"+ if L[now] == R[now]:",
"+ print((i + 1))",
"+ i += c",
"+ now += 1",
"+ i += 1",
"-def yutori():",
"- N, K, C = list(map(int, sys.stdin.readline().split()))",
"- S = [i for i in sys.stdin.readline()]",
"- l = [i + 1 for i in range(N) if S[i] == \"o\"]",
"- Left = []",
"- Right = []",
"- for u in l:",
"- if Left == []:",
"- Left.append(u)",
"- if u > Left[-1] + C:",
"- Left.append(u)",
"- if len(Right) == K:",
"- break",
"- if len(Left) < K:",
"- exit()",
"- for u in l[::-1]:",
"- if Right == []:",
"- Right.append(u)",
"- if u < Right[-1] - C:",
"- Right.append(u)",
"- if len(Right) == K:",
"- break",
"- if len(Right) < K:",
"- exit()",
"- for i in range(K):",
"- if Left[i] == Right[-i - 1]:",
"- print((Left[i]))",
"-",
"-",
"-yutori()",
"+if __name__ == \"__main__\":",
"+ main()"
] | false
| 0.043635
| 0.042548
| 1.025536
|
[
"s537597021",
"s937496988"
] |
u767797498
|
p02623
|
python
|
s113529247
|
s054122762
| 1,230
| 677
| 41,460
| 41,456
|
Accepted
|
Accepted
| 44.96
|
# -*- coding: utf-8 -*-
import io
import sys
import math
def solve(n,m,k,a_lst,b_lst):
#机ごと、読書時間の累積をリストにする。ただし、リスト化はk時間内で読める範囲とする
aa_lst = make_sum_list(a_lst,k)
bb_lst = make_sum_list(b_lst,k)
len_aa = len(aa_lst)
len_bb = len(bb_lst)
#A,Bいずれかが一冊も読めないケースを考慮
if len_aa == 0: return len_bb
elif len_bb == 0: return len_aa
#全て読めるケースを考慮
if aa_lst[-1] + bb_lst[-1] <= k: return len_aa + len_bb
#A,Bいずれかのみ読むケースを考慮
max_read = max(len_aa,len_bb)
#リスト範囲でA+Bの最大値を探索する。2分探索を用いる
for i in reversed(list(range(len_aa))):
limit = k - aa_lst[i]
read = i + 1
if read + len_bb + 1 <= max_read:
#以後 read は増えない
break
imax = len_bb-1
imin = 0
imid = len_bb // 2
while True:
logd(f"imid: {imid}")
if bb_lst[imid] <= limit:
#OK。大を調べる
if imax - imid <= 1:
#探査終了
if bb_lst[imax] <= limit:
read += imax + 1
else:
read += imid + 1
break
imin = imid
else:
#NG。小を調べる
if imid - imin <= 1:
#探査完了
if bb_lst[imin] <= limit:
read += imin + 1
break
imax = imid
imid = (imin + imax) // 2
max_read = max(read,max_read)
return max_read
def make_sum_list(lst,max):
sum_lst = []
sum = 0
for n in lst:
sum += n
if sum > max:
break
sum_lst.append(sum)
return sum_lst
def main():
n,m,k = list(map(int, input().split()))
a_lst = list(map(int, input().split()))
b_lst = list(map(int, input().split()))
ans = solve(n,m,k,a_lst,b_lst)
print(ans)
### DEBUG I/O ###
_INPUT = """\
3 4 240
60 90 120
80 150 80 150
"""
_DEBUG = 0
def logd(str):
if _DEBUG:
print(f"[deb] {str}")
### MAIN ###
if __name__ == "__main__":
if _DEBUG:
sys.stdin = io.StringIO(_INPUT)
print("!! Debug Mode !!")
main()
|
# -*- coding: utf-8 -*-
import io
import sys
import math
def solve(n,m,k,a_lst,b_lst):
#机ごと、読書時間の累積をリストにする。ただし、リスト化はk時間内で読める範囲とする
aa_lst = make_sum_list(a_lst,k)
bb_lst = make_sum_list(b_lst,k)
len_aa = len(aa_lst)
len_bb = len(bb_lst)
#A,Bいずれかが一冊も読めないケースを考慮
if len_aa == 0: return len_bb
elif len_bb == 0: return len_aa
#全て読めるケースを考慮
if aa_lst[-1] + bb_lst[-1] <= k: return len_aa + len_bb
#A,Bいずれかのみ読むケースを考慮
max_read = max(len_aa,len_bb)
#リスト範囲でA+Bの最大値を探索する。2分探索を用いる
for i in reversed(list(range(len_aa))):
limit = k - aa_lst[i]
read = i + 1
if read + len_bb + 1 <= max_read:
#以後 read は増えない
break
imax = len_bb-1
imin = 0
imid = len_bb // 2
while True:
if _DEB: logd(f"imid: {imid}")
if bb_lst[imid] <= limit:
#OK。大を調べる
if imax - imid <= 1:
#探査終了
if bb_lst[imax] <= limit:
read += imax + 1
else:
read += imid + 1
break
imin = imid
else:
#NG。小を調べる
if imid - imin <= 1:
#探査完了
if bb_lst[imin] <= limit:
read += imin + 1
break
imax = imid
imid = (imin + imax) // 2
max_read = max(read,max_read)
return max_read
def make_sum_list(lst,max):
sum_lst = []
sum = 0
for n in lst:
sum += n
if sum > max:
break
sum_lst.append(sum)
return sum_lst
def main():
n,m,k = list(map(int, input().split()))
a_lst = list(map(int, input().split()))
b_lst = list(map(int, input().split()))
ans = solve(n,m,k,a_lst,b_lst)
print(ans)
### DEBUG I/O ###
_INPUT = """\
3 4 240
60 90 120
80 150 80 150
"""
_DEB = 0
def logd(str):
if _DEB:
print(f"[deb] {str}")
### MAIN ###
if __name__ == "__main__":
if _DEB:
sys.stdin = io.StringIO(_INPUT)
print("!! Debug Mode !!")
main()
| 96
| 96
| 2,264
| 2,267
|
# -*- coding: utf-8 -*-
import io
import sys
import math
def solve(n, m, k, a_lst, b_lst):
# 机ごと、読書時間の累積をリストにする。ただし、リスト化はk時間内で読める範囲とする
aa_lst = make_sum_list(a_lst, k)
bb_lst = make_sum_list(b_lst, k)
len_aa = len(aa_lst)
len_bb = len(bb_lst)
# A,Bいずれかが一冊も読めないケースを考慮
if len_aa == 0:
return len_bb
elif len_bb == 0:
return len_aa
# 全て読めるケースを考慮
if aa_lst[-1] + bb_lst[-1] <= k:
return len_aa + len_bb
# A,Bいずれかのみ読むケースを考慮
max_read = max(len_aa, len_bb)
# リスト範囲でA+Bの最大値を探索する。2分探索を用いる
for i in reversed(list(range(len_aa))):
limit = k - aa_lst[i]
read = i + 1
if read + len_bb + 1 <= max_read:
# 以後 read は増えない
break
imax = len_bb - 1
imin = 0
imid = len_bb // 2
while True:
logd(f"imid: {imid}")
if bb_lst[imid] <= limit:
# OK。大を調べる
if imax - imid <= 1:
# 探査終了
if bb_lst[imax] <= limit:
read += imax + 1
else:
read += imid + 1
break
imin = imid
else:
# NG。小を調べる
if imid - imin <= 1:
# 探査完了
if bb_lst[imin] <= limit:
read += imin + 1
break
imax = imid
imid = (imin + imax) // 2
max_read = max(read, max_read)
return max_read
def make_sum_list(lst, max):
sum_lst = []
sum = 0
for n in lst:
sum += n
if sum > max:
break
sum_lst.append(sum)
return sum_lst
def main():
n, m, k = list(map(int, input().split()))
a_lst = list(map(int, input().split()))
b_lst = list(map(int, input().split()))
ans = solve(n, m, k, a_lst, b_lst)
print(ans)
### DEBUG I/O ###
_INPUT = """\
3 4 240
60 90 120
80 150 80 150
"""
_DEBUG = 0
def logd(str):
if _DEBUG:
print(f"[deb] {str}")
### MAIN ###
if __name__ == "__main__":
if _DEBUG:
sys.stdin = io.StringIO(_INPUT)
print("!! Debug Mode !!")
main()
|
# -*- coding: utf-8 -*-
import io
import sys
import math
def solve(n, m, k, a_lst, b_lst):
# 机ごと、読書時間の累積をリストにする。ただし、リスト化はk時間内で読める範囲とする
aa_lst = make_sum_list(a_lst, k)
bb_lst = make_sum_list(b_lst, k)
len_aa = len(aa_lst)
len_bb = len(bb_lst)
# A,Bいずれかが一冊も読めないケースを考慮
if len_aa == 0:
return len_bb
elif len_bb == 0:
return len_aa
# 全て読めるケースを考慮
if aa_lst[-1] + bb_lst[-1] <= k:
return len_aa + len_bb
# A,Bいずれかのみ読むケースを考慮
max_read = max(len_aa, len_bb)
# リスト範囲でA+Bの最大値を探索する。2分探索を用いる
for i in reversed(list(range(len_aa))):
limit = k - aa_lst[i]
read = i + 1
if read + len_bb + 1 <= max_read:
# 以後 read は増えない
break
imax = len_bb - 1
imin = 0
imid = len_bb // 2
while True:
if _DEB:
logd(f"imid: {imid}")
if bb_lst[imid] <= limit:
# OK。大を調べる
if imax - imid <= 1:
# 探査終了
if bb_lst[imax] <= limit:
read += imax + 1
else:
read += imid + 1
break
imin = imid
else:
# NG。小を調べる
if imid - imin <= 1:
# 探査完了
if bb_lst[imin] <= limit:
read += imin + 1
break
imax = imid
imid = (imin + imax) // 2
max_read = max(read, max_read)
return max_read
def make_sum_list(lst, max):
sum_lst = []
sum = 0
for n in lst:
sum += n
if sum > max:
break
sum_lst.append(sum)
return sum_lst
def main():
n, m, k = list(map(int, input().split()))
a_lst = list(map(int, input().split()))
b_lst = list(map(int, input().split()))
ans = solve(n, m, k, a_lst, b_lst)
print(ans)
### DEBUG I/O ###
_INPUT = """\
3 4 240
60 90 120
80 150 80 150
"""
_DEB = 0
def logd(str):
if _DEB:
print(f"[deb] {str}")
### MAIN ###
if __name__ == "__main__":
if _DEB:
sys.stdin = io.StringIO(_INPUT)
print("!! Debug Mode !!")
main()
| false
| 0
|
[
"- logd(f\"imid: {imid}\")",
"+ if _DEB:",
"+ logd(f\"imid: {imid}\")",
"-_DEBUG = 0",
"+_DEB = 0",
"- if _DEBUG:",
"+ if _DEB:",
"- if _DEBUG:",
"+ if _DEB:"
] | false
| 0.03566
| 0.038164
| 0.934398
|
[
"s113529247",
"s054122762"
] |
u977389981
|
p03252
|
python
|
s269021834
|
s342607187
| 252
| 42
| 4,144
| 3,888
|
Accepted
|
Accepted
| 83.33
|
from collections import Counter
S = eval(input())
T = eval(input())
lenS = len(Counter(S))
lenT = len(Counter(T))
flag = 0
if lenS == lenT:
for i in range(lenS):
if Counter(S).most_common()[i][1] == Counter(T).most_common()[i][1]:
continue
else:
flag = 1
break
else:
flag = 1
if flag == 0:
print('Yes')
else:
print('No')
|
from collections import Counter
S = sorted(Counter(eval(input())).values())
T = sorted(Counter(eval(input())).values())
if S == T:
print('Yes')
else:
print('No')
| 23
| 9
| 406
| 167
|
from collections import Counter
S = eval(input())
T = eval(input())
lenS = len(Counter(S))
lenT = len(Counter(T))
flag = 0
if lenS == lenT:
for i in range(lenS):
if Counter(S).most_common()[i][1] == Counter(T).most_common()[i][1]:
continue
else:
flag = 1
break
else:
flag = 1
if flag == 0:
print("Yes")
else:
print("No")
|
from collections import Counter
S = sorted(Counter(eval(input())).values())
T = sorted(Counter(eval(input())).values())
if S == T:
print("Yes")
else:
print("No")
| false
| 60.869565
|
[
"-S = eval(input())",
"-T = eval(input())",
"-lenS = len(Counter(S))",
"-lenT = len(Counter(T))",
"-flag = 0",
"-if lenS == lenT:",
"- for i in range(lenS):",
"- if Counter(S).most_common()[i][1] == Counter(T).most_common()[i][1]:",
"- continue",
"- else:",
"- flag = 1",
"- break",
"-else:",
"- flag = 1",
"-if flag == 0:",
"+S = sorted(Counter(eval(input())).values())",
"+T = sorted(Counter(eval(input())).values())",
"+if S == T:"
] | false
| 0.093199
| 0.035749
| 2.607006
|
[
"s269021834",
"s342607187"
] |
u272557899
|
p03078
|
python
|
s375392019
|
s179632642
| 739
| 393
| 151,640
| 56,536
|
Accepted
|
Accepted
| 46.82
|
x, y, z, k = list(map(int, input().split()))
a = [int(m) for m in input().split()]
b = [int(m) for m in input().split()]
c = [int(m) for m in input().split()]
a.sort(reverse=True)
b.sort(reverse=True)
c.sort(reverse=True)
s = []
for i in range(x):
for j in range(y):
s.append(a[i] + b[j])
s.sort(reverse=True)
s1 = []
for i in range(min(x * y, k)):
s1.append(s[i])
t = []
for i in range(min(x * y, k)):
for j in range(z):
t.append(s1[i] + c[j])
t.sort(reverse=True)
for i in range(k):
print((t[i]))
|
from heapq import heappush, heappop
x, y, z, k = list(map(int, input().split()))
a = [int(m) for m in input().split()]
b = [int(m) for m in input().split()]
c = [int(m) for m in input().split()]
a.sort(reverse=True)
b.sort(reverse=True)
c.sort(reverse=True)
Q = [[-(a[0] + b[0] + c[0]), 0, 0, 0]]
ansli = []
se = set()
se.add("0,0,0")
for i in range(k):
tmp = heappop(Q)
ansli.append(tmp)
if tmp[1] != x - 1 and str(tmp[1] + 1) + "," + str(tmp[2]) + "," + str(tmp[3]) not in se:
heappush(Q, [-(a[tmp[1] + 1] + b[tmp[2]] + c[tmp[3]]), tmp[1] + 1, tmp[2], tmp[3]])
se.add(str(tmp[1] + 1) + "," + str(tmp[2]) + "," + str(tmp[3]))
if tmp[2] != y - 1 and str(tmp[1]) + "," + str(tmp[2] + 1) + "," + str(tmp[3]) not in se:
heappush(Q, [-(a[tmp[1]] + b[tmp[2] + 1] + c[tmp[3]]), tmp[1], tmp[2] + 1, tmp[3]])
se.add(str(tmp[1]) + "," + str(tmp[2] + 1) + "," + str(tmp[3]))
if tmp[3] != z - 1 and str(tmp[1]) + "," + str(tmp[2]) + "," + str(tmp[3] + 1) not in se:
heappush(Q, [-(a[tmp[1]] + b[tmp[2]] + c[tmp[3] + 1]), tmp[1], tmp[2], tmp[3] + 1])
se.add(str(tmp[1]) + "," + str(tmp[2]) + "," + str(tmp[3] + 1))
for i in range(k):
print((-ansli[i][0]))
| 26
| 28
| 551
| 1,236
|
x, y, z, k = list(map(int, input().split()))
a = [int(m) for m in input().split()]
b = [int(m) for m in input().split()]
c = [int(m) for m in input().split()]
a.sort(reverse=True)
b.sort(reverse=True)
c.sort(reverse=True)
s = []
for i in range(x):
for j in range(y):
s.append(a[i] + b[j])
s.sort(reverse=True)
s1 = []
for i in range(min(x * y, k)):
s1.append(s[i])
t = []
for i in range(min(x * y, k)):
for j in range(z):
t.append(s1[i] + c[j])
t.sort(reverse=True)
for i in range(k):
print((t[i]))
|
from heapq import heappush, heappop
x, y, z, k = list(map(int, input().split()))
a = [int(m) for m in input().split()]
b = [int(m) for m in input().split()]
c = [int(m) for m in input().split()]
a.sort(reverse=True)
b.sort(reverse=True)
c.sort(reverse=True)
Q = [[-(a[0] + b[0] + c[0]), 0, 0, 0]]
ansli = []
se = set()
se.add("0,0,0")
for i in range(k):
tmp = heappop(Q)
ansli.append(tmp)
if (
tmp[1] != x - 1
and str(tmp[1] + 1) + "," + str(tmp[2]) + "," + str(tmp[3]) not in se
):
heappush(
Q, [-(a[tmp[1] + 1] + b[tmp[2]] + c[tmp[3]]), tmp[1] + 1, tmp[2], tmp[3]]
)
se.add(str(tmp[1] + 1) + "," + str(tmp[2]) + "," + str(tmp[3]))
if (
tmp[2] != y - 1
and str(tmp[1]) + "," + str(tmp[2] + 1) + "," + str(tmp[3]) not in se
):
heappush(
Q, [-(a[tmp[1]] + b[tmp[2] + 1] + c[tmp[3]]), tmp[1], tmp[2] + 1, tmp[3]]
)
se.add(str(tmp[1]) + "," + str(tmp[2] + 1) + "," + str(tmp[3]))
if (
tmp[3] != z - 1
and str(tmp[1]) + "," + str(tmp[2]) + "," + str(tmp[3] + 1) not in se
):
heappush(
Q, [-(a[tmp[1]] + b[tmp[2]] + c[tmp[3] + 1]), tmp[1], tmp[2], tmp[3] + 1]
)
se.add(str(tmp[1]) + "," + str(tmp[2]) + "," + str(tmp[3] + 1))
for i in range(k):
print((-ansli[i][0]))
| false
| 7.142857
|
[
"+from heapq import heappush, heappop",
"+",
"-s = []",
"-for i in range(x):",
"- for j in range(y):",
"- s.append(a[i] + b[j])",
"-s.sort(reverse=True)",
"-s1 = []",
"-for i in range(min(x * y, k)):",
"- s1.append(s[i])",
"-t = []",
"-for i in range(min(x * y, k)):",
"- for j in range(z):",
"- t.append(s1[i] + c[j])",
"-t.sort(reverse=True)",
"+Q = [[-(a[0] + b[0] + c[0]), 0, 0, 0]]",
"+ansli = []",
"+se = set()",
"+se.add(\"0,0,0\")",
"- print((t[i]))",
"+ tmp = heappop(Q)",
"+ ansli.append(tmp)",
"+ if (",
"+ tmp[1] != x - 1",
"+ and str(tmp[1] + 1) + \",\" + str(tmp[2]) + \",\" + str(tmp[3]) not in se",
"+ ):",
"+ heappush(",
"+ Q, [-(a[tmp[1] + 1] + b[tmp[2]] + c[tmp[3]]), tmp[1] + 1, tmp[2], tmp[3]]",
"+ )",
"+ se.add(str(tmp[1] + 1) + \",\" + str(tmp[2]) + \",\" + str(tmp[3]))",
"+ if (",
"+ tmp[2] != y - 1",
"+ and str(tmp[1]) + \",\" + str(tmp[2] + 1) + \",\" + str(tmp[3]) not in se",
"+ ):",
"+ heappush(",
"+ Q, [-(a[tmp[1]] + b[tmp[2] + 1] + c[tmp[3]]), tmp[1], tmp[2] + 1, tmp[3]]",
"+ )",
"+ se.add(str(tmp[1]) + \",\" + str(tmp[2] + 1) + \",\" + str(tmp[3]))",
"+ if (",
"+ tmp[3] != z - 1",
"+ and str(tmp[1]) + \",\" + str(tmp[2]) + \",\" + str(tmp[3] + 1) not in se",
"+ ):",
"+ heappush(",
"+ Q, [-(a[tmp[1]] + b[tmp[2]] + c[tmp[3] + 1]), tmp[1], tmp[2], tmp[3] + 1]",
"+ )",
"+ se.add(str(tmp[1]) + \",\" + str(tmp[2]) + \",\" + str(tmp[3] + 1))",
"+for i in range(k):",
"+ print((-ansli[i][0]))"
] | false
| 0.0654
| 0.043268
| 1.511534
|
[
"s375392019",
"s179632642"
] |
u345966487
|
p03311
|
python
|
s073912925
|
s937098455
| 252
| 204
| 26,180
| 25,184
|
Accepted
|
Accepted
| 19.05
|
N = int(eval(input()))
A = list(map(int,input().split()))
B = sorted(A[i] - i - 1 for i in range(N))
def sad(b):
return sum(abs(A[i] - i - 1 - b)for i in range(N))
print((min(sad(B[N//2]),sad(B[min(N//2+1,N-1)]))))
|
N=int(eval(input()))
B=sorted(int(x)-i-1 for i,x in enumerate(input().split()))
def sad(x):
return sum(abs(b-x)for b in B)
print((sad(B[N//2])))
| 6
| 5
| 216
| 145
|
N = int(eval(input()))
A = list(map(int, input().split()))
B = sorted(A[i] - i - 1 for i in range(N))
def sad(b):
return sum(abs(A[i] - i - 1 - b) for i in range(N))
print((min(sad(B[N // 2]), sad(B[min(N // 2 + 1, N - 1)]))))
|
N = int(eval(input()))
B = sorted(int(x) - i - 1 for i, x in enumerate(input().split()))
def sad(x):
return sum(abs(b - x) for b in B)
print((sad(B[N // 2])))
| false
| 16.666667
|
[
"-A = list(map(int, input().split()))",
"-B = sorted(A[i] - i - 1 for i in range(N))",
"+B = sorted(int(x) - i - 1 for i, x in enumerate(input().split()))",
"-def sad(b):",
"- return sum(abs(A[i] - i - 1 - b) for i in range(N))",
"+def sad(x):",
"+ return sum(abs(b - x) for b in B)",
"-print((min(sad(B[N // 2]), sad(B[min(N // 2 + 1, N - 1)]))))",
"+print((sad(B[N // 2])))"
] | false
| 0.048648
| 0.171332
| 0.283942
|
[
"s073912925",
"s937098455"
] |
u670567845
|
p03408
|
python
|
s129634504
|
s553210642
| 467
| 80
| 82,828
| 67,160
|
Accepted
|
Accepted
| 82.87
|
import collections
n = int(eval(input()))
b = [eval(input()) for _ in range(n)]
m = int(eval(input()))
r = [eval(input()) for _ in range(m)]
bc = collections.Counter(b)
rc = collections.Counter(r)
ans = 0
for x in list(bc.keys()):
ans = max(ans, bc[x]-rc[x])
print(ans)
|
import collections
n = int(eval(input()))
s = [eval(input()) for _ in range(n)]
m = int(eval(input()))
t = [eval(input()) for _ in range(m)]
sc = collections.Counter(s)
tc = collections.Counter(t)
ans = 0
for x in list(sc.keys()):
ans = max(ans,sc[x]-tc[x])
print(ans)
| 11
| 12
| 251
| 252
|
import collections
n = int(eval(input()))
b = [eval(input()) for _ in range(n)]
m = int(eval(input()))
r = [eval(input()) for _ in range(m)]
bc = collections.Counter(b)
rc = collections.Counter(r)
ans = 0
for x in list(bc.keys()):
ans = max(ans, bc[x] - rc[x])
print(ans)
|
import collections
n = int(eval(input()))
s = [eval(input()) for _ in range(n)]
m = int(eval(input()))
t = [eval(input()) for _ in range(m)]
sc = collections.Counter(s)
tc = collections.Counter(t)
ans = 0
for x in list(sc.keys()):
ans = max(ans, sc[x] - tc[x])
print(ans)
| false
| 8.333333
|
[
"-b = [eval(input()) for _ in range(n)]",
"+s = [eval(input()) for _ in range(n)]",
"-r = [eval(input()) for _ in range(m)]",
"-bc = collections.Counter(b)",
"-rc = collections.Counter(r)",
"+t = [eval(input()) for _ in range(m)]",
"+sc = collections.Counter(s)",
"+tc = collections.Counter(t)",
"-for x in list(bc.keys()):",
"- ans = max(ans, bc[x] - rc[x])",
"+for x in list(sc.keys()):",
"+ ans = max(ans, sc[x] - tc[x])"
] | false
| 0.079991
| 0.036668
| 2.181501
|
[
"s129634504",
"s553210642"
] |
u027685417
|
p02898
|
python
|
s486281517
|
s787050349
| 63
| 49
| 11,912
| 11,912
|
Accepted
|
Accepted
| 22.22
|
N, K = list(map(int, input().split()))
list_h = list(map(int, input().split()))
list_h.sort()
list_h.insert(0, 0)
list_h.append(500)
L, R = 0, N + 1
while R - L > 1:
C = (L + R) // 2
if list_h[C] >= K:
R = C
else:
L = C
print((len(list_h[R:-1])))
|
N, K = list(map(int, input().split()))
list_h = list(map(int, input().split()))
count = 0
for i in list_h:
if i >= K:
count += 1
print(count)
| 16
| 9
| 285
| 158
|
N, K = list(map(int, input().split()))
list_h = list(map(int, input().split()))
list_h.sort()
list_h.insert(0, 0)
list_h.append(500)
L, R = 0, N + 1
while R - L > 1:
C = (L + R) // 2
if list_h[C] >= K:
R = C
else:
L = C
print((len(list_h[R:-1])))
|
N, K = list(map(int, input().split()))
list_h = list(map(int, input().split()))
count = 0
for i in list_h:
if i >= K:
count += 1
print(count)
| false
| 43.75
|
[
"-list_h.sort()",
"-list_h.insert(0, 0)",
"-list_h.append(500)",
"-L, R = 0, N + 1",
"-while R - L > 1:",
"- C = (L + R) // 2",
"- if list_h[C] >= K:",
"- R = C",
"- else:",
"- L = C",
"-print((len(list_h[R:-1])))",
"+count = 0",
"+for i in list_h:",
"+ if i >= K:",
"+ count += 1",
"+print(count)"
] | false
| 0.038081
| 0.047577
| 0.800396
|
[
"s486281517",
"s787050349"
] |
u680851063
|
p03111
|
python
|
s941291882
|
s431743349
| 305
| 254
| 12,788
| 3,316
|
Accepted
|
Accepted
| 16.72
|
# ＤＦＳ, パターン列挙_竹'n'本の使用パターン
n, a, b, c = list(map(int, input().split()))
l = [int(eval(input())) for _ in range(n)]
stack = [[0],[1],[2],[-1]] # 初期化_ここでは竹の使用パターン4つを設置
ptns = [] # パターン候補の器_初期化
while stack: # stackが空になるまでループ
tmp = stack.pop() # パターンの候補を pop
if len(tmp) == n: # 条件に合えば append
ptns.append(tmp)
elif len(tmp) < n: # 条件に合わなければ...
w = tmp + [0] # パターンの候補を作成して...
x = tmp + [1] # 〃
y = tmp + [2] # 〃
z = tmp + [-1]
stack += [w, x, y, z] # 積む
#print(ptns) # 竹の使用パターン
ans = 10**9
for i in range(len(ptns)):
if 0 not in ptns[i] or 1 not in ptns[i] or 2 not in ptns[i]:
continue
abc = [0, 0, 0, -30]
for j in range(n):
tmp = ptns[i][j]
if tmp >= 0:
abc[tmp] += l[j]
abc[3] += 10
mp = abc[3]
mp += abs(abc[0] - a)
mp += abs(abc[1] - b)
mp += abs(abc[2] - c)
ans = min(ans, mp)
print(ans)
'''
# パターン列挙と探索を並行して処理
n, a, b, c = map(int, input().split())
l = [int(input()) for _ in range(n)]
stack = [[0],[1],[2],[-1]]
ans = 10**9
while stack:
tmp = stack.pop()
if len(tmp) == n:
if 0 not in tmp or 1 not in tmp or 2 not in tmp:
continue
abc = [0, 0, 0, -30]
for j in range(n):
if tmp[j] >= 0:
abc[tmp[j]] += l[j]
abc[3] += 10
mp = abc[3]
mp += abs(abc[0] - a)
mp += abs(abc[1] - b)
mp += abs(abc[2] - c)
ans = min(ans, mp)
elif len(tmp) < n:
w = tmp + [0]
x = tmp + [1]
y = tmp + [2]
z = tmp + [-1]
stack += [w, x, y, z]
print(ans)
'''
|
# ＤＦＳ, パターン列挙_竹'n'本の使用パターン
'''
from collections import deque
n, a, b, c = map(int, input().split())
l = [int(input()) for _ in range(n)]
queue = deque([[0],[1],[2],[-1]]) # 初期化_ここでは竹の使用パターン4つを設置
ptns = [] # パターン候補の器_初期化
while queue: # stackが空になるまでループ
tmp = queue.pop() # パターンの候補を pop
if len(tmp) == n: # 条件に合えば append
ptns.append(tmp)
elif len(tmp) < n: # 条件に合わなければ...
w = tmp + [0] # パターンの候補を作成して...
x = tmp + [1] # 〃
y = tmp + [2] # 〃
z = tmp + [-1]
queue += [w, x, y, z] # 積む
#print(ptns) # 竹の使用パターン
ans = 10**9
for i in range(len(ptns)):
if 0 not in ptns[i] or 1 not in ptns[i] or 2 not in ptns[i]:
continue
abc = [0, 0, 0, -30]
for j in range(n):
tmp = ptns[i][j]
if tmp >= 0:
abc[tmp] += l[j]
abc[3] += 10
mp = abc[3]
mp += abs(abc[0] - a)
mp += abs(abc[1] - b)
mp += abs(abc[2] - c)
ans = min(ans, mp)
print(ans)
'''
# パターン列挙と探索を並行して処理
from collections import deque
n, a, b, c = list(map(int, input().split()))
l = [int(eval(input())) for _ in range(n)]
queue = deque([[0],[1],[2],[-1]])
ans = 10**9
while queue:
tmp = queue.pop()
if len(tmp) == n:
if 0 not in tmp or 1 not in tmp or 2 not in tmp:
continue
abc = [0, 0, 0, -30]
for j in range(n):
if tmp[j] >= 0:
abc[tmp[j]] += l[j]
abc[3] += 10
mp = abc[3]
mp += abs(abc[0] - a)
mp += abs(abc[1] - b)
mp += abs(abc[2] - c)
ans = min(ans, mp)
elif len(tmp) < n:
w = tmp + [0]
x = tmp + [1]
y = tmp + [2]
z = tmp + [-1]
queue += [w, x, y, z]
print(ans)
| 73
| 76
| 1,720
| 1,799
|
# ＤＦＳ, パターン列挙_竹'n'本の使用パターン
n, a, b, c = list(map(int, input().split()))
l = [int(eval(input())) for _ in range(n)]
stack = [[0], [1], [2], [-1]] # 初期化_ここでは竹の使用パターン4つを設置
ptns = [] # パターン候補の器_初期化
while stack: # stackが空になるまでループ
tmp = stack.pop() # パターンの候補を pop
if len(tmp) == n: # 条件に合えば append
ptns.append(tmp)
elif len(tmp) < n: # 条件に合わなければ...
w = tmp + [0] # パターンの候補を作成して...
x = tmp + [1] # 〃
y = tmp + [2] # 〃
z = tmp + [-1]
stack += [w, x, y, z] # 積む
# print(ptns) # 竹の使用パターン
ans = 10**9
for i in range(len(ptns)):
if 0 not in ptns[i] or 1 not in ptns[i] or 2 not in ptns[i]:
continue
abc = [0, 0, 0, -30]
for j in range(n):
tmp = ptns[i][j]
if tmp >= 0:
abc[tmp] += l[j]
abc[3] += 10
mp = abc[3]
mp += abs(abc[0] - a)
mp += abs(abc[1] - b)
mp += abs(abc[2] - c)
ans = min(ans, mp)
print(ans)
"""
# パターン列挙と探索を並行して処理
n, a, b, c = map(int, input().split())
l = [int(input()) for _ in range(n)]
stack = [[0],[1],[2],[-1]]
ans = 10**9
while stack:
tmp = stack.pop()
if len(tmp) == n:
if 0 not in tmp or 1 not in tmp or 2 not in tmp:
continue
abc = [0, 0, 0, -30]
for j in range(n):
if tmp[j] >= 0:
abc[tmp[j]] += l[j]
abc[3] += 10
mp = abc[3]
mp += abs(abc[0] - a)
mp += abs(abc[1] - b)
mp += abs(abc[2] - c)
ans = min(ans, mp)
elif len(tmp) < n:
w = tmp + [0]
x = tmp + [1]
y = tmp + [2]
z = tmp + [-1]
stack += [w, x, y, z]
print(ans)
"""
|
# ＤＦＳ, パターン列挙_竹'n'本の使用パターン
"""
from collections import deque
n, a, b, c = map(int, input().split())
l = [int(input()) for _ in range(n)]
queue = deque([[0],[1],[2],[-1]]) # 初期化_ここでは竹の使用パターン4つを設置
ptns = [] # パターン候補の器_初期化
while queue: # stackが空になるまでループ
tmp = queue.pop() # パターンの候補を pop
if len(tmp) == n: # 条件に合えば append
ptns.append(tmp)
elif len(tmp) < n: # 条件に合わなければ...
w = tmp + [0] # パターンの候補を作成して...
x = tmp + [1] # 〃
y = tmp + [2] # 〃
z = tmp + [-1]
queue += [w, x, y, z] # 積む
#print(ptns) # 竹の使用パターン
ans = 10**9
for i in range(len(ptns)):
if 0 not in ptns[i] or 1 not in ptns[i] or 2 not in ptns[i]:
continue
abc = [0, 0, 0, -30]
for j in range(n):
tmp = ptns[i][j]
if tmp >= 0:
abc[tmp] += l[j]
abc[3] += 10
mp = abc[3]
mp += abs(abc[0] - a)
mp += abs(abc[1] - b)
mp += abs(abc[2] - c)
ans = min(ans, mp)
print(ans)
"""
# パターン列挙と探索を並行して処理
from collections import deque
n, a, b, c = list(map(int, input().split()))
l = [int(eval(input())) for _ in range(n)]
queue = deque([[0], [1], [2], [-1]])
ans = 10**9
while queue:
tmp = queue.pop()
if len(tmp) == n:
if 0 not in tmp or 1 not in tmp or 2 not in tmp:
continue
abc = [0, 0, 0, -30]
for j in range(n):
if tmp[j] >= 0:
abc[tmp[j]] += l[j]
abc[3] += 10
mp = abc[3]
mp += abs(abc[0] - a)
mp += abs(abc[1] - b)
mp += abs(abc[2] - c)
ans = min(ans, mp)
elif len(tmp) < n:
w = tmp + [0]
x = tmp + [1]
y = tmp + [2]
z = tmp + [-1]
queue += [w, x, y, z]
print(ans)
| false
| 3.947368
|
[
"-n, a, b, c = list(map(int, input().split()))",
"-l = [int(eval(input())) for _ in range(n)]",
"-stack = [[0], [1], [2], [-1]] # 初期化_ここでは竹の使用パターン4つを設置",
"-ptns = [] # パターン候補の器_初期化",
"-while stack: # stackが空になるまでループ",
"- tmp = stack.pop() # パターンの候補を pop",
"- if len(tmp) == n: # 条件に合えば append",
"+\"\"\"",
"+from collections import deque",
"+n, a, b, c = map(int, input().split())",
"+l = [int(input()) for _ in range(n)]",
"+queue = deque([[0],[1],[2],[-1]]) # 初期化_ここでは竹の使用パターン4つを設置",
"+ptns = [] # パターン候補の器_初期化",
"+while queue: # stackが空になるまでループ",
"+ tmp = queue.pop() # パターンの候補を pop",
"+ if len(tmp) == n: # 条件に合えば append",
"- elif len(tmp) < n: # 条件に合わなければ...",
"- w = tmp + [0] # パターンの候補を作成して...",
"- x = tmp + [1] # 〃",
"- y = tmp + [2] # 〃",
"+ elif len(tmp) < n: # 条件に合わなければ...",
"+ w = tmp + [0] # パターンの候補を作成して...",
"+ x = tmp + [1] # 〃",
"+ y = tmp + [2] # 〃",
"- stack += [w, x, y, z] # 積む",
"-# print(ptns) # 竹の使用パターン",
"+ queue += [w, x, y, z] # 積む",
"+#print(ptns) # 竹の使用パターン",
"-n, a, b, c = map(int, input().split())",
"-l = [int(input()) for _ in range(n)]",
"-stack = [[0],[1],[2],[-1]]",
"+from collections import deque",
"+",
"+n, a, b, c = list(map(int, input().split()))",
"+l = [int(eval(input())) for _ in range(n)]",
"+queue = deque([[0], [1], [2], [-1]])",
"-while stack:",
"- tmp = stack.pop()",
"+while queue:",
"+ tmp = queue.pop()",
"- stack += [w, x, y, z]",
"+ queue += [w, x, y, z]",
"-\"\"\""
] | false
| 0.391801
| 0.218421
| 1.793786
|
[
"s941291882",
"s431743349"
] |
u078276601
|
p02623
|
python
|
s308368744
|
s181382490
| 291
| 237
| 47,372
| 50,624
|
Accepted
|
Accepted
| 18.56
|
n,m,k = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
a,b = [0], [0]
for i in range(n):
a.append(a[i]+A[i])
for j in range(m):
b.append(b[j]+B[j])
ans, j = 0, m
for i in range(n+1):
if a[i] > k:
break
while a[i] + b[j] > k:
j -= 1
ans = max(ans, i+j)
print(ans)
|
import itertools
n,m,k = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
acc_A = [0]+list(itertools.accumulate(A))
acc_B = [0]+list(itertools.accumulate(B))
ans, j = 0, m
for i in range(n+1):
if acc_A[i] > k:
break
while acc_A[i] + acc_B[j] > k:
j -= 1
ans = max(ans, i+j)
print(ans)
| 19
| 18
| 374
| 399
|
n, m, k = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
a, b = [0], [0]
for i in range(n):
a.append(a[i] + A[i])
for j in range(m):
b.append(b[j] + B[j])
ans, j = 0, m
for i in range(n + 1):
if a[i] > k:
break
while a[i] + b[j] > k:
j -= 1
ans = max(ans, i + j)
print(ans)
|
import itertools
n, m, k = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
acc_A = [0] + list(itertools.accumulate(A))
acc_B = [0] + list(itertools.accumulate(B))
ans, j = 0, m
for i in range(n + 1):
if acc_A[i] > k:
break
while acc_A[i] + acc_B[j] > k:
j -= 1
ans = max(ans, i + j)
print(ans)
| false
| 5.263158
|
[
"+import itertools",
"+",
"-a, b = [0], [0]",
"-for i in range(n):",
"- a.append(a[i] + A[i])",
"-for j in range(m):",
"- b.append(b[j] + B[j])",
"+acc_A = [0] + list(itertools.accumulate(A))",
"+acc_B = [0] + list(itertools.accumulate(B))",
"- if a[i] > k:",
"+ if acc_A[i] > k:",
"- while a[i] + b[j] > k:",
"+ while acc_A[i] + acc_B[j] > k:"
] | false
| 0.048615
| 0.039213
| 1.239763
|
[
"s308368744",
"s181382490"
] |
u612243550
|
p02259
|
python
|
s913152147
|
s958250548
| 30
| 20
| 7,664
| 7,672
|
Accepted
|
Accepted
| 33.33
|
n = int(eval(input()))
A = input().split(' ')
count = 0
flag = True
while flag:
flag = False
for j in reversed(list(range(1, n))):
if int(A[j]) < int(A[j-1]):
(A[j-1], A[j]) = (A[j], A[j-1])
count += 1
flag = True
print((" ".join(A)))
print(count)
|
n = int(eval(input()))
A = input().split(' ')
count = 0
flag = True
while flag:
flag = False
i = 0
for j in reversed(list(range(i + 1, n))):
if int(A[j]) < int(A[j-1]):
(A[j-1], A[j]) = (A[j], A[j-1])
count += 1
flag = True
i += 1
print((" ".join(A)))
print(count)
| 15
| 20
| 301
| 334
|
n = int(eval(input()))
A = input().split(" ")
count = 0
flag = True
while flag:
flag = False
for j in reversed(list(range(1, n))):
if int(A[j]) < int(A[j - 1]):
(A[j - 1], A[j]) = (A[j], A[j - 1])
count += 1
flag = True
print((" ".join(A)))
print(count)
|
n = int(eval(input()))
A = input().split(" ")
count = 0
flag = True
while flag:
flag = False
i = 0
for j in reversed(list(range(i + 1, n))):
if int(A[j]) < int(A[j - 1]):
(A[j - 1], A[j]) = (A[j], A[j - 1])
count += 1
flag = True
i += 1
print((" ".join(A)))
print(count)
| false
| 25
|
[
"- for j in reversed(list(range(1, n))):",
"+ i = 0",
"+ for j in reversed(list(range(i + 1, n))):",
"+ i += 1"
] | false
| 0.066897
| 0.067788
| 0.986857
|
[
"s913152147",
"s958250548"
] |
u698919163
|
p02678
|
python
|
s894320667
|
s863691553
| 623
| 466
| 34,192
| 121,876
|
Accepted
|
Accepted
| 25.2
|
from collections import deque
import sys
N,M = list(map(int,input().split()))
graph = [[] for _ in range(N + 1)]
for i in range(M):
a,b = list(map(int,input().split()))
graph[a].append(b)
graph[b].append(a)
que = deque([1])
ans = [0]*(N+1)
while que:
x = deque.popleft(que)
for i in graph[x]:
if ans[i] != 0:
continue
ans[i] = x
que.append(i)
for i in range(2,N+1):
if ans[i] == 0:
print('No')
sys.exit()
print('Yes')
for i in range(2,N+1):
print((ans[i]))
|
N,M = list(map(int,input().split()))
AB = [list(map(int,input().split())) for i in range(M)]
ans = [-1] * (N+1)
graph = [[] for _ in range(N+1)]
for a,b in AB:
graph[a].append(b)
graph[b].append(a)
from collections import deque
import sys
ans = [-1] * (N+1)
todo = deque([(1,0)])
while todo:
x,parent = deque.popleft(todo)
#ans[x] = parent
for y in graph[x]:
# if y == parent:
# continue
if ans[y] != -1:
continue
ans[y] = x
todo.append((y,x))
for i in range(2,N+1):
if ans[i] == -1:
print('No')
sys.exit()
print('Yes')
for i in range(2,N+1):
print((ans[i]))
| 29
| 34
| 571
| 710
|
from collections import deque
import sys
N, M = list(map(int, input().split()))
graph = [[] for _ in range(N + 1)]
for i in range(M):
a, b = list(map(int, input().split()))
graph[a].append(b)
graph[b].append(a)
que = deque([1])
ans = [0] * (N + 1)
while que:
x = deque.popleft(que)
for i in graph[x]:
if ans[i] != 0:
continue
ans[i] = x
que.append(i)
for i in range(2, N + 1):
if ans[i] == 0:
print("No")
sys.exit()
print("Yes")
for i in range(2, N + 1):
print((ans[i]))
|
N, M = list(map(int, input().split()))
AB = [list(map(int, input().split())) for i in range(M)]
ans = [-1] * (N + 1)
graph = [[] for _ in range(N + 1)]
for a, b in AB:
graph[a].append(b)
graph[b].append(a)
from collections import deque
import sys
ans = [-1] * (N + 1)
todo = deque([(1, 0)])
while todo:
x, parent = deque.popleft(todo)
# ans[x] = parent
for y in graph[x]:
# if y == parent:
# continue
if ans[y] != -1:
continue
ans[y] = x
todo.append((y, x))
for i in range(2, N + 1):
if ans[i] == -1:
print("No")
sys.exit()
print("Yes")
for i in range(2, N + 1):
print((ans[i]))
| false
| 14.705882
|
[
"+N, M = list(map(int, input().split()))",
"+AB = [list(map(int, input().split())) for i in range(M)]",
"+ans = [-1] * (N + 1)",
"+graph = [[] for _ in range(N + 1)]",
"+for a, b in AB:",
"+ graph[a].append(b)",
"+ graph[b].append(a)",
"-N, M = list(map(int, input().split()))",
"-graph = [[] for _ in range(N + 1)]",
"-for i in range(M):",
"- a, b = list(map(int, input().split()))",
"- graph[a].append(b)",
"- graph[b].append(a)",
"-que = deque([1])",
"-ans = [0] * (N + 1)",
"-while que:",
"- x = deque.popleft(que)",
"- for i in graph[x]:",
"- if ans[i] != 0:",
"+ans = [-1] * (N + 1)",
"+todo = deque([(1, 0)])",
"+while todo:",
"+ x, parent = deque.popleft(todo)",
"+ # ans[x] = parent",
"+ for y in graph[x]:",
"+ # if y == parent:",
"+ # continue",
"+ if ans[y] != -1:",
"- ans[i] = x",
"- que.append(i)",
"+ ans[y] = x",
"+ todo.append((y, x))",
"- if ans[i] == 0:",
"+ if ans[i] == -1:"
] | false
| 0.041841
| 0.041488
| 1.008502
|
[
"s894320667",
"s863691553"
] |
u092650292
|
p02958
|
python
|
s585715983
|
s956440216
| 348
| 24
| 21,596
| 3,700
|
Accepted
|
Accepted
| 93.1
|
import numpy as np
def main():
n = int(eval(input()))
p = list(map(int,input().split()))
a = np.array(list(range(1,n+1)))
p = np.array(p)
ans = len(np.where((a-p)!=0)[0])
if ans <= 2:
print('YES')
else:
print('NO')
main()
|
#from math import gcd
from math import factorial as f
from math import ceil,floor,sqrt
import bisect
import re
import heapq
from copy import deepcopy
import itertools
from sys import exit
ii = lambda : int(eval(input()))
mi = lambda : list(map(int,input().split()))
li = lambda : list(map(int,input().split()))
yes = "Yes"
no = "No"
def main():
n=ii()
p = li()
cnt = 0
for i in range(1,n+1):
if i!=p[i-1]:
cnt+=1
if cnt<=2:
print('YES')
else:
print('NO')
main()
| 21
| 41
| 288
| 565
|
import numpy as np
def main():
n = int(eval(input()))
p = list(map(int, input().split()))
a = np.array(list(range(1, n + 1)))
p = np.array(p)
ans = len(np.where((a - p) != 0)[0])
if ans <= 2:
print("YES")
else:
print("NO")
main()
|
# from math import gcd
from math import factorial as f
from math import ceil, floor, sqrt
import bisect
import re
import heapq
from copy import deepcopy
import itertools
from sys import exit
ii = lambda: int(eval(input()))
mi = lambda: list(map(int, input().split()))
li = lambda: list(map(int, input().split()))
yes = "Yes"
no = "No"
def main():
n = ii()
p = li()
cnt = 0
for i in range(1, n + 1):
if i != p[i - 1]:
cnt += 1
if cnt <= 2:
print("YES")
else:
print("NO")
main()
| false
| 48.780488
|
[
"-import numpy as np",
"+# from math import gcd",
"+from math import factorial as f",
"+from math import ceil, floor, sqrt",
"+import bisect",
"+import re",
"+import heapq",
"+from copy import deepcopy",
"+import itertools",
"+from sys import exit",
"+",
"+ii = lambda: int(eval(input()))",
"+mi = lambda: list(map(int, input().split()))",
"+li = lambda: list(map(int, input().split()))",
"+yes = \"Yes\"",
"+no = \"No\"",
"- n = int(eval(input()))",
"- p = list(map(int, input().split()))",
"- a = np.array(list(range(1, n + 1)))",
"- p = np.array(p)",
"- ans = len(np.where((a - p) != 0)[0])",
"- if ans <= 2:",
"+ n = ii()",
"+ p = li()",
"+ cnt = 0",
"+ for i in range(1, n + 1):",
"+ if i != p[i - 1]:",
"+ cnt += 1",
"+ if cnt <= 2:"
] | false
| 0.389757
| 0.03665
| 10.634559
|
[
"s585715983",
"s956440216"
] |
u608088992
|
p03127
|
python
|
s393779202
|
s016807087
| 109
| 85
| 14,224
| 20,016
|
Accepted
|
Accepted
| 22.02
|
N = int(eval(input()))
A = [int(a) for a in input().split()]
def GCD(a, b):
a, b = max(a, b), min(a, b)
while a % b != 0:
a, b = b, a%b
return b
Ans = GCD(A[0], A[1])
for i in range(2, N):
Ans = GCD(Ans, A[i])
print(Ans)
|
import sys
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():
input = sys.stdin.readline
N = int(eval(input()))
A = [int(i) for i in input().split()]
gcdA = A[0]
for a in A: gcdA = gcd(gcdA, a)
print(gcdA)
return 0
if __name__ == "__main__":
solve()
| 13
| 20
| 252
| 365
|
N = int(eval(input()))
A = [int(a) for a in input().split()]
def GCD(a, b):
a, b = max(a, b), min(a, b)
while a % b != 0:
a, b = b, a % b
return b
Ans = GCD(A[0], A[1])
for i in range(2, N):
Ans = GCD(Ans, A[i])
print(Ans)
|
import sys
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():
input = sys.stdin.readline
N = int(eval(input()))
A = [int(i) for i in input().split()]
gcdA = A[0]
for a in A:
gcdA = gcd(gcdA, a)
print(gcdA)
return 0
if __name__ == "__main__":
solve()
| false
| 35
|
[
"-N = int(eval(input()))",
"-A = [int(a) for a in input().split()]",
"+import sys",
"-def GCD(a, b):",
"+def gcd(a, b):",
"- while a % b != 0:",
"+ while a % b > 0:",
"-Ans = GCD(A[0], A[1])",
"-for i in range(2, N):",
"- Ans = GCD(Ans, A[i])",
"-print(Ans)",
"+def solve():",
"+ input = sys.stdin.readline",
"+ N = int(eval(input()))",
"+ A = [int(i) for i in input().split()]",
"+ gcdA = A[0]",
"+ for a in A:",
"+ gcdA = gcd(gcdA, a)",
"+ print(gcdA)",
"+ return 0",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ solve()"
] | false
| 0.046702
| 0.045179
| 1.03372
|
[
"s393779202",
"s016807087"
] |
u282228874
|
p03111
|
python
|
s284950684
|
s261754080
| 73
| 61
| 3,064
| 3,064
|
Accepted
|
Accepted
| 16.44
|
N,A,B,C = list(map(int,input().split()))
l = [int(eval(input())) for i in range(N)]
INF = 10**9+7
def dfs(count,a,b,c):
if count == N:
if min(a,b,c) > 0:
return abs(a-A)+abs(b-B)+abs(c-C)-30
else:
return INF
non = dfs(count+1,a,b,c)
useA = dfs(count+1,a+l[count],b,c)+10
useB = dfs(count+1,a,b+l[count],c)+10
useC = dfs(count+1,a,b,c+l[count])+10
return min(non,useA,useB,useC)
print((dfs(0,0,0,0)))
|
N,A,B,C = list(map(int,input().split()))
L = [int(eval(input())) for i in range(N)]
def dfs(cnt,la,lb,lc,cost):
if cnt == N:
if la == 0 or lb == 0 or lc == 0:
return 10**10
else:
return cost+abs(A-la)+abs(B-lb)+abs(C-lc)-30
else:
a = dfs(cnt+1,la+L[cnt],lb,lc,cost+10)
b = dfs(cnt+1,la,lb+L[cnt],lc,cost+10)
c = dfs(cnt+1,la,lb,lc+L[cnt],cost+10)
d = dfs(cnt+1,la,lb,lc,cost)
return min(a,b,c,d)
print((dfs(0,0,0,0,0)))
| 17
| 17
| 419
| 512
|
N, A, B, C = list(map(int, input().split()))
l = [int(eval(input())) for i in range(N)]
INF = 10**9 + 7
def dfs(count, a, b, c):
if count == N:
if min(a, b, c) > 0:
return abs(a - A) + abs(b - B) + abs(c - C) - 30
else:
return INF
non = dfs(count + 1, a, b, c)
useA = dfs(count + 1, a + l[count], b, c) + 10
useB = dfs(count + 1, a, b + l[count], c) + 10
useC = dfs(count + 1, a, b, c + l[count]) + 10
return min(non, useA, useB, useC)
print((dfs(0, 0, 0, 0)))
|
N, A, B, C = list(map(int, input().split()))
L = [int(eval(input())) for i in range(N)]
def dfs(cnt, la, lb, lc, cost):
if cnt == N:
if la == 0 or lb == 0 or lc == 0:
return 10**10
else:
return cost + abs(A - la) + abs(B - lb) + abs(C - lc) - 30
else:
a = dfs(cnt + 1, la + L[cnt], lb, lc, cost + 10)
b = dfs(cnt + 1, la, lb + L[cnt], lc, cost + 10)
c = dfs(cnt + 1, la, lb, lc + L[cnt], cost + 10)
d = dfs(cnt + 1, la, lb, lc, cost)
return min(a, b, c, d)
print((dfs(0, 0, 0, 0, 0)))
| false
| 0
|
[
"-l = [int(eval(input())) for i in range(N)]",
"-INF = 10**9 + 7",
"+L = [int(eval(input())) for i in range(N)]",
"-def dfs(count, a, b, c):",
"- if count == N:",
"- if min(a, b, c) > 0:",
"- return abs(a - A) + abs(b - B) + abs(c - C) - 30",
"+def dfs(cnt, la, lb, lc, cost):",
"+ if cnt == N:",
"+ if la == 0 or lb == 0 or lc == 0:",
"+ return 10**10",
"- return INF",
"- non = dfs(count + 1, a, b, c)",
"- useA = dfs(count + 1, a + l[count], b, c) + 10",
"- useB = dfs(count + 1, a, b + l[count], c) + 10",
"- useC = dfs(count + 1, a, b, c + l[count]) + 10",
"- return min(non, useA, useB, useC)",
"+ return cost + abs(A - la) + abs(B - lb) + abs(C - lc) - 30",
"+ else:",
"+ a = dfs(cnt + 1, la + L[cnt], lb, lc, cost + 10)",
"+ b = dfs(cnt + 1, la, lb + L[cnt], lc, cost + 10)",
"+ c = dfs(cnt + 1, la, lb, lc + L[cnt], cost + 10)",
"+ d = dfs(cnt + 1, la, lb, lc, cost)",
"+ return min(a, b, c, d)",
"-print((dfs(0, 0, 0, 0)))",
"+print((dfs(0, 0, 0, 0, 0)))"
] | false
| 0.059719
| 0.077302
| 0.772541
|
[
"s284950684",
"s261754080"
] |
u562935282
|
p02659
|
python
|
s923208044
|
s581386615
| 26
| 22
| 10,068
| 9,176
|
Accepted
|
Accepted
| 15.38
|
def main():
from decimal import Decimal
A, B = list(map(Decimal, input().split()))
print((int(A * B)))
if __name__ == '__main__':
main()
# import sys
# input = sys.stdin.readline
#
# sys.setrecursionlimit(10 ** 7)
#
# (int(x)-1 for x in input().split())
# rstrip()
#
# def binary_search(*, ok, ng, func):
# while abs(ok - ng) > 1:
# mid = (ok + ng) // 2
# if func(mid):
# ok = mid
# else:
# ng = mid
# return ok
|
def main():
A, B = input().split()
A = int(A)
B_int, B_frac = list(map(int, B.split('.'))) # 整数部分, 小数部分
L = len(str(B_frac)) # 小数部分の桁数
ans = (A * (B_int * 100 + B_frac)) // 100
print(ans)
if __name__ == '__main__':
main()
| 25
| 14
| 505
| 264
|
def main():
from decimal import Decimal
A, B = list(map(Decimal, input().split()))
print((int(A * B)))
if __name__ == "__main__":
main()
# import sys
# input = sys.stdin.readline
#
# sys.setrecursionlimit(10 ** 7)
#
# (int(x)-1 for x in input().split())
# rstrip()
#
# def binary_search(*, ok, ng, func):
# while abs(ok - ng) > 1:
# mid = (ok + ng) // 2
# if func(mid):
# ok = mid
# else:
# ng = mid
# return ok
|
def main():
A, B = input().split()
A = int(A)
B_int, B_frac = list(map(int, B.split("."))) # 整数部分, 小数部分
L = len(str(B_frac)) # 小数部分の桁数
ans = (A * (B_int * 100 + B_frac)) // 100
print(ans)
if __name__ == "__main__":
main()
| false
| 44
|
[
"- from decimal import Decimal",
"-",
"- A, B = list(map(Decimal, input().split()))",
"- print((int(A * B)))",
"+ A, B = input().split()",
"+ A = int(A)",
"+ B_int, B_frac = list(map(int, B.split(\".\"))) # 整数部分, 小数部分",
"+ L = len(str(B_frac)) # 小数部分の桁数",
"+ ans = (A * (B_int * 100 + B_frac)) // 100",
"+ print(ans)",
"-# import sys",
"-# input = sys.stdin.readline",
"-#",
"-# sys.setrecursionlimit(10 ** 7)",
"-#",
"-# (int(x)-1 for x in input().split())",
"-# rstrip()",
"-#",
"-# def binary_search(*, ok, ng, func):",
"-# while abs(ok - ng) > 1:",
"-# mid = (ok + ng) // 2",
"-# if func(mid):",
"-# ok = mid",
"-# else:",
"-# ng = mid",
"-# return ok"
] | false
| 0.050702
| 0.047102
| 1.07644
|
[
"s923208044",
"s581386615"
] |
u045176840
|
p03448
|
python
|
s713382080
|
s662847536
| 53
| 29
| 9,108
| 9,136
|
Accepted
|
Accepted
| 45.28
|
# import numpy as np
A_init = 500
B_init = 100
C_init = 50
A_n = int(eval(input()))
B_n = int(eval(input()))
C_n = int(eval(input()))
X = int(eval(input()))
cnt = 0
for a in range(A_n+1):
if A_init * a <= X:
for b in range(B_n+1):
if (A_init * a + B_init * b) <= X:
for c in range(C_n+1):
if (A_init * a + B_init * b + C_init * c) == X: cnt += 1
else:
break
else:
break
# print(np.count_nonzero([k+[i for i in All_list] == X for k in All_list]))
print(cnt)
|
# import numpy as np
A_init = 500
B_init = 100
C_init = 50
A_n = int(eval(input()))
B_n = int(eval(input()))
C_n = int(eval(input()))
X = int(eval(input()))
cnt = 0
for a in range(A_n+1):
if A_init * a <= X:
for b in range(B_n+1):
if (A_init * a + B_init * b) <= X:
K = X - (A_init * a + B_init * b)
if K % 50 == 0 and K / C_init <= C_n:
cnt += 1
else:
break
else:
break
# print(np.count_nonzero([k+[i for i in All_list] == X for k in All_list]))
print(cnt)
| 25
| 26
| 560
| 578
|
# import numpy as np
A_init = 500
B_init = 100
C_init = 50
A_n = int(eval(input()))
B_n = int(eval(input()))
C_n = int(eval(input()))
X = int(eval(input()))
cnt = 0
for a in range(A_n + 1):
if A_init * a <= X:
for b in range(B_n + 1):
if (A_init * a + B_init * b) <= X:
for c in range(C_n + 1):
if (A_init * a + B_init * b + C_init * c) == X:
cnt += 1
else:
break
else:
break
# print(np.count_nonzero([k+[i for i in All_list] == X for k in All_list]))
print(cnt)
|
# import numpy as np
A_init = 500
B_init = 100
C_init = 50
A_n = int(eval(input()))
B_n = int(eval(input()))
C_n = int(eval(input()))
X = int(eval(input()))
cnt = 0
for a in range(A_n + 1):
if A_init * a <= X:
for b in range(B_n + 1):
if (A_init * a + B_init * b) <= X:
K = X - (A_init * a + B_init * b)
if K % 50 == 0 and K / C_init <= C_n:
cnt += 1
else:
break
else:
break
# print(np.count_nonzero([k+[i for i in All_list] == X for k in All_list]))
print(cnt)
| false
| 3.846154
|
[
"- for c in range(C_n + 1):",
"- if (A_init * a + B_init * b + C_init * c) == X:",
"- cnt += 1",
"+ K = X - (A_init * a + B_init * b)",
"+ if K % 50 == 0 and K / C_init <= C_n:",
"+ cnt += 1"
] | false
| 0.051732
| 0.03997
| 1.294259
|
[
"s713382080",
"s662847536"
] |
u309018392
|
p02712
|
python
|
s927507696
|
s947350406
| 216
| 147
| 52,684
| 52,832
|
Accepted
|
Accepted
| 31.94
|
n = int(eval(input()))
a = []
for i in range(1,n+1):
a.append(i)
new_a = [i for i in a if i%3 != 0 and i%5 != 0]
print((sum(new_a)))
|
n = int(eval(input()))
a = list(range(1,n+1))
new_a = [i for i in a if i%3 != 0 and i%5 != 0]
print((sum(new_a)))
| 6
| 4
| 134
| 109
|
n = int(eval(input()))
a = []
for i in range(1, n + 1):
a.append(i)
new_a = [i for i in a if i % 3 != 0 and i % 5 != 0]
print((sum(new_a)))
|
n = int(eval(input()))
a = list(range(1, n + 1))
new_a = [i for i in a if i % 3 != 0 and i % 5 != 0]
print((sum(new_a)))
| false
| 33.333333
|
[
"-a = []",
"-for i in range(1, n + 1):",
"- a.append(i)",
"+a = list(range(1, n + 1))"
] | false
| 0.56311
| 0.181468
| 3.10308
|
[
"s927507696",
"s947350406"
] |
u265939044
|
p03457
|
python
|
s656026712
|
s034699562
| 495
| 430
| 32,148
| 32,148
|
Accepted
|
Accepted
| 13.13
|
T = 0
X = 1
Y = 2
item = eval(input())
tabiji = [[0,0,0]]
for i in range(1, int(item)+1):
tabiji.append(input().split(' '))
a = 'Yes'
for i in range(0, len(tabiji)-1):
time = int(tabiji[i+1][T]) - int(tabiji[i][T])
dX = int(tabiji[i+1][X]) - int(tabiji[i][X])
dY = int(tabiji[i+1][Y]) - int(tabiji[i][Y])
for j in range(time):
if dX > 0:
dX -= 1
elif dX < 0:
dX += 1
elif dY > 0:
dY -= 1
elif dY < 0:
dY += 1
if dX == 0 and dY == 0 and (time - j+1) % 2 == 1:
a = 'No'
break
elif dX == 0 and dY == 0 and (time - j+1) % 2 == 0:
break
if dX != 0 or dY != 0:
a = 'No'
print(a)
|
T = 0
X = 1
Y = 2
item = eval(input())
tabiji = [[0,0,0]]
for i in range(1, int(item)+1):
tabiji.append(input().split(' '))
a = 'Yes'
for i in range(0, len(tabiji)-1):
time = int(tabiji[i+1][T]) - int(tabiji[i][T])
dX = abs(int(tabiji[i+1][X]) - int(tabiji[i][X]))
dY = abs(int(tabiji[i+1][Y]) - int(tabiji[i][Y]))
dtime = time - dX - dY
if dtime < 0 or dtime % 2 == 1:
a = 'No'
print(a)
| 31
| 18
| 762
| 432
|
T = 0
X = 1
Y = 2
item = eval(input())
tabiji = [[0, 0, 0]]
for i in range(1, int(item) + 1):
tabiji.append(input().split(" "))
a = "Yes"
for i in range(0, len(tabiji) - 1):
time = int(tabiji[i + 1][T]) - int(tabiji[i][T])
dX = int(tabiji[i + 1][X]) - int(tabiji[i][X])
dY = int(tabiji[i + 1][Y]) - int(tabiji[i][Y])
for j in range(time):
if dX > 0:
dX -= 1
elif dX < 0:
dX += 1
elif dY > 0:
dY -= 1
elif dY < 0:
dY += 1
if dX == 0 and dY == 0 and (time - j + 1) % 2 == 1:
a = "No"
break
elif dX == 0 and dY == 0 and (time - j + 1) % 2 == 0:
break
if dX != 0 or dY != 0:
a = "No"
print(a)
|
T = 0
X = 1
Y = 2
item = eval(input())
tabiji = [[0, 0, 0]]
for i in range(1, int(item) + 1):
tabiji.append(input().split(" "))
a = "Yes"
for i in range(0, len(tabiji) - 1):
time = int(tabiji[i + 1][T]) - int(tabiji[i][T])
dX = abs(int(tabiji[i + 1][X]) - int(tabiji[i][X]))
dY = abs(int(tabiji[i + 1][Y]) - int(tabiji[i][Y]))
dtime = time - dX - dY
if dtime < 0 or dtime % 2 == 1:
a = "No"
print(a)
| false
| 41.935484
|
[
"- dX = int(tabiji[i + 1][X]) - int(tabiji[i][X])",
"- dY = int(tabiji[i + 1][Y]) - int(tabiji[i][Y])",
"- for j in range(time):",
"- if dX > 0:",
"- dX -= 1",
"- elif dX < 0:",
"- dX += 1",
"- elif dY > 0:",
"- dY -= 1",
"- elif dY < 0:",
"- dY += 1",
"- if dX == 0 and dY == 0 and (time - j + 1) % 2 == 1:",
"- a = \"No\"",
"- break",
"- elif dX == 0 and dY == 0 and (time - j + 1) % 2 == 0:",
"- break",
"- if dX != 0 or dY != 0:",
"+ dX = abs(int(tabiji[i + 1][X]) - int(tabiji[i][X]))",
"+ dY = abs(int(tabiji[i + 1][Y]) - int(tabiji[i][Y]))",
"+ dtime = time - dX - dY",
"+ if dtime < 0 or dtime % 2 == 1:"
] | false
| 0.052597
| 0.034476
| 1.525603
|
[
"s656026712",
"s034699562"
] |
u379959788
|
p03241
|
python
|
s331062307
|
s541951234
| 694
| 20
| 3,060
| 3,188
|
Accepted
|
Accepted
| 97.12
|
def is_prime(N):
if N == 1:
return False
for k in range(2, int(N**0.5) + 1):
if N % k == 0:
return False
return True
N, M = list(map(int, input().split()))
k = 0
if N != 1:
if is_prime(M):
print((1))
exit()
while True:
if M % (N + k) == 0:
ans = M // (N+k)
break
k += 1
print(ans)
|
import bisect
def make_divisors(N):
divisors = []
for i in range(1, int(N**0.5)+1):
if N % i == 0:
divisors.append(i)
if i != N // i:
divisors.append(N//i)
divisors.sort()
return divisors
N, M = list(map(int, input().split()))
lst = make_divisors(M)
print((lst[bisect.bisect_right(lst, M//N)-1]))
| 21
| 13
| 378
| 364
|
def is_prime(N):
if N == 1:
return False
for k in range(2, int(N**0.5) + 1):
if N % k == 0:
return False
return True
N, M = list(map(int, input().split()))
k = 0
if N != 1:
if is_prime(M):
print((1))
exit()
while True:
if M % (N + k) == 0:
ans = M // (N + k)
break
k += 1
print(ans)
|
import bisect
def make_divisors(N):
divisors = []
for i in range(1, int(N**0.5) + 1):
if N % i == 0:
divisors.append(i)
if i != N // i:
divisors.append(N // i)
divisors.sort()
return divisors
N, M = list(map(int, input().split()))
lst = make_divisors(M)
print((lst[bisect.bisect_right(lst, M // N) - 1]))
| false
| 38.095238
|
[
"-def is_prime(N):",
"- if N == 1:",
"- return False",
"- for k in range(2, int(N**0.5) + 1):",
"- if N % k == 0:",
"- return False",
"- return True",
"+import bisect",
"+",
"+",
"+def make_divisors(N):",
"+ divisors = []",
"+ for i in range(1, int(N**0.5) + 1):",
"+ if N % i == 0:",
"+ divisors.append(i)",
"+ if i != N // i:",
"+ divisors.append(N // i)",
"+ divisors.sort()",
"+ return divisors",
"-k = 0",
"-if N != 1:",
"- if is_prime(M):",
"- print((1))",
"- exit()",
"-while True:",
"- if M % (N + k) == 0:",
"- ans = M // (N + k)",
"- break",
"- k += 1",
"-print(ans)",
"+lst = make_divisors(M)",
"+print((lst[bisect.bisect_right(lst, M // N) - 1]))"
] | false
| 0.106012
| 0.037858
| 2.800243
|
[
"s331062307",
"s541951234"
] |
u467736898
|
p02575
|
python
|
s231234324
|
s428222815
| 1,741
| 694
| 146,000
| 53,596
|
Accepted
|
Accepted
| 60.14
|
H, W = list(map(int, input().split()))
AB = [list(map(int, input().split())) for _ in range(H)]
A = W+1
identity = -(1<<62)
sqrtA = 500
n_buckets = A // sqrtA + 1
Data = [0] * (n_buckets * sqrtA)
Data[0] = 1<<30
Bucket_min = [0] * n_buckets
Lazy = [identity] * n_buckets
def eval_data(k):
if Lazy[k] != identity:
l, r = k*sqrtA, (k+1) * sqrtA
for i in range(l, r):
Data[i] = i-Lazy[k]
Lazy[k] = identity
def update(s, t, x):
for k in range(s//sqrtA, (t-1)//sqrtA+1):
l, r = k*sqrtA, (k+1)*sqrtA
if s <= l and r <= t:
Bucket_min[k] = l-x
Lazy[k] = x
else:
eval_data(k)
for i in range(max(l,s), min(r,t)):
Data[i] = i-x
Bucket_min[k] = min(Data[l:r])
def get_min(s, t):
res = 1 << 62
bl, br = s//sqrtA+1, t//sqrtA
if bl > br:
eval_data(br)
return min(Data[s:t])
if bl < br:
res = min(Bucket_min[bl:br])
ll, rr = bl*sqrtA, br*sqrtA
if s < ll:
eval_data(bl-1)
mi = min(Data[s:ll])
if res > mi:
res = mi
if rr < t:
eval_data(br)
mi = min(Data[rr:t])
if res > mi:
res = mi
return res
Ans = []
for i, (a, b) in enumerate(AB, 1):
update(a, b+1, a-1-get_min(a-1, a))
ans = get_min(1, W+1)
Ans.append(ans + i if ans < 1<<25 else -1)
print(("\n".join(map(str, Ans))))
|
def numba_compile(numba_config):
import os, sys
if sys.argv[-1] == "ONLINE_JUDGE":
from numba import njit
from numba.pycc import CC
cc = CC("my_module")
for func, signature in numba_config:
globals()[func.__name__] = njit(signature)(func)
cc.export(func.__name__, signature)(func)
cc.compile()
exit()
elif os.name == "posix":
exec(f"from my_module import {','.join(func.__name__ for func, _ in numba_config)}")
for func, _ in numba_config:
globals()[func.__name__] = vars()[func.__name__]
else:
from numba import njit
for func, signature in numba_config:
globals()[func.__name__] = njit(signature, cache=True)(func)
print("compiled!", file=sys.stderr)
import sys
import numpy as np
def solve(H, W, AB):
A = W+1
identity = -(1<<62)
sqrtA = 500
n_buckets = A // sqrtA + 1
Data = np.zeros(n_buckets * sqrtA, dtype=np.int64)
Data[0] = 1<<30
Bucket_min = np.zeros(n_buckets, dtype=np.int64)
Lazy = np.full(n_buckets, identity, dtype=np.int64)
def eval_data(k):
if Lazy[k] != identity:
l, r = k*sqrtA, (k+1) * sqrtA
for i in range(l, r):
Data[i] = i-Lazy[k]
Lazy[k] = identity
def update(s, t, x):
for k in range(s//sqrtA, (t-1)//sqrtA+1):
l, r = k*sqrtA, (k+1)*sqrtA
if s <= l and r <= t:
Bucket_min[k] = l-x
Lazy[k] = x
else:
eval_data(k)
for i in range(max(l,s), min(r,t)):
Data[i] = i-x
Bucket_min[k] = Data[l:r].min()
def get_min(s, t):
res = 1 << 62
bl, br = s//sqrtA+1, t//sqrtA
if bl > br:
eval_data(br)
return Data[s:t].min()
if bl < br:
res = Bucket_min[bl:br].min()
ll, rr = bl*sqrtA, br*sqrtA
if s < ll:
eval_data(bl-1)
mi = Data[s:ll].min()
if res > mi:
res = mi
if rr < t:
eval_data(br)
mi = Data[rr:t].min()
if res > mi:
res = mi
return res
Ans = np.zeros(H, dtype=np.int64)
for i in range(H):
a, b = AB[i]
update(a, b+1, a-1-get_min(a-1, a))
ans = get_min(1, W+1)
Ans[i] = ans+i+1 if ans < 1<<25 else -1
return Ans
numba_compile([
[solve, "i8[:](i8,i8,i8[:,:])"]
])
def main():
H, W = map(int, sys.stdin.buffer.readline().split())
AB = np.array(sys.stdin.buffer.read().split(), dtype=np.int64).reshape(H, 2)
Ans = solve(H, W, AB)
print("\n".join(map(str, Ans.tolist())))
main()
| 58
| 94
| 1,495
| 2,859
|
H, W = list(map(int, input().split()))
AB = [list(map(int, input().split())) for _ in range(H)]
A = W + 1
identity = -(1 << 62)
sqrtA = 500
n_buckets = A // sqrtA + 1
Data = [0] * (n_buckets * sqrtA)
Data[0] = 1 << 30
Bucket_min = [0] * n_buckets
Lazy = [identity] * n_buckets
def eval_data(k):
if Lazy[k] != identity:
l, r = k * sqrtA, (k + 1) * sqrtA
for i in range(l, r):
Data[i] = i - Lazy[k]
Lazy[k] = identity
def update(s, t, x):
for k in range(s // sqrtA, (t - 1) // sqrtA + 1):
l, r = k * sqrtA, (k + 1) * sqrtA
if s <= l and r <= t:
Bucket_min[k] = l - x
Lazy[k] = x
else:
eval_data(k)
for i in range(max(l, s), min(r, t)):
Data[i] = i - x
Bucket_min[k] = min(Data[l:r])
def get_min(s, t):
res = 1 << 62
bl, br = s // sqrtA + 1, t // sqrtA
if bl > br:
eval_data(br)
return min(Data[s:t])
if bl < br:
res = min(Bucket_min[bl:br])
ll, rr = bl * sqrtA, br * sqrtA
if s < ll:
eval_data(bl - 1)
mi = min(Data[s:ll])
if res > mi:
res = mi
if rr < t:
eval_data(br)
mi = min(Data[rr:t])
if res > mi:
res = mi
return res
Ans = []
for i, (a, b) in enumerate(AB, 1):
update(a, b + 1, a - 1 - get_min(a - 1, a))
ans = get_min(1, W + 1)
Ans.append(ans + i if ans < 1 << 25 else -1)
print(("\n".join(map(str, Ans))))
|
def numba_compile(numba_config):
import os, sys
if sys.argv[-1] == "ONLINE_JUDGE":
from numba import njit
from numba.pycc import CC
cc = CC("my_module")
for func, signature in numba_config:
globals()[func.__name__] = njit(signature)(func)
cc.export(func.__name__, signature)(func)
cc.compile()
exit()
elif os.name == "posix":
exec(
f"from my_module import {','.join(func.__name__ for func, _ in numba_config)}"
)
for func, _ in numba_config:
globals()[func.__name__] = vars()[func.__name__]
else:
from numba import njit
for func, signature in numba_config:
globals()[func.__name__] = njit(signature, cache=True)(func)
print("compiled!", file=sys.stderr)
import sys
import numpy as np
def solve(H, W, AB):
A = W + 1
identity = -(1 << 62)
sqrtA = 500
n_buckets = A // sqrtA + 1
Data = np.zeros(n_buckets * sqrtA, dtype=np.int64)
Data[0] = 1 << 30
Bucket_min = np.zeros(n_buckets, dtype=np.int64)
Lazy = np.full(n_buckets, identity, dtype=np.int64)
def eval_data(k):
if Lazy[k] != identity:
l, r = k * sqrtA, (k + 1) * sqrtA
for i in range(l, r):
Data[i] = i - Lazy[k]
Lazy[k] = identity
def update(s, t, x):
for k in range(s // sqrtA, (t - 1) // sqrtA + 1):
l, r = k * sqrtA, (k + 1) * sqrtA
if s <= l and r <= t:
Bucket_min[k] = l - x
Lazy[k] = x
else:
eval_data(k)
for i in range(max(l, s), min(r, t)):
Data[i] = i - x
Bucket_min[k] = Data[l:r].min()
def get_min(s, t):
res = 1 << 62
bl, br = s // sqrtA + 1, t // sqrtA
if bl > br:
eval_data(br)
return Data[s:t].min()
if bl < br:
res = Bucket_min[bl:br].min()
ll, rr = bl * sqrtA, br * sqrtA
if s < ll:
eval_data(bl - 1)
mi = Data[s:ll].min()
if res > mi:
res = mi
if rr < t:
eval_data(br)
mi = Data[rr:t].min()
if res > mi:
res = mi
return res
Ans = np.zeros(H, dtype=np.int64)
for i in range(H):
a, b = AB[i]
update(a, b + 1, a - 1 - get_min(a - 1, a))
ans = get_min(1, W + 1)
Ans[i] = ans + i + 1 if ans < 1 << 25 else -1
return Ans
numba_compile([[solve, "i8[:](i8,i8,i8[:,:])"]])
def main():
H, W = map(int, sys.stdin.buffer.readline().split())
AB = np.array(sys.stdin.buffer.read().split(), dtype=np.int64).reshape(H, 2)
Ans = solve(H, W, AB)
print("\n".join(map(str, Ans.tolist())))
main()
| false
| 38.297872
|
[
"-H, W = list(map(int, input().split()))",
"-AB = [list(map(int, input().split())) for _ in range(H)]",
"-A = W + 1",
"-identity = -(1 << 62)",
"-sqrtA = 500",
"-n_buckets = A // sqrtA + 1",
"-Data = [0] * (n_buckets * sqrtA)",
"-Data[0] = 1 << 30",
"-Bucket_min = [0] * n_buckets",
"-Lazy = [identity] * n_buckets",
"+def numba_compile(numba_config):",
"+ import os, sys",
"+",
"+ if sys.argv[-1] == \"ONLINE_JUDGE\":",
"+ from numba import njit",
"+ from numba.pycc import CC",
"+",
"+ cc = CC(\"my_module\")",
"+ for func, signature in numba_config:",
"+ globals()[func.__name__] = njit(signature)(func)",
"+ cc.export(func.__name__, signature)(func)",
"+ cc.compile()",
"+ exit()",
"+ elif os.name == \"posix\":",
"+ exec(",
"+ f\"from my_module import {','.join(func.__name__ for func, _ in numba_config)}\"",
"+ )",
"+ for func, _ in numba_config:",
"+ globals()[func.__name__] = vars()[func.__name__]",
"+ else:",
"+ from numba import njit",
"+",
"+ for func, signature in numba_config:",
"+ globals()[func.__name__] = njit(signature, cache=True)(func)",
"+ print(\"compiled!\", file=sys.stderr)",
"-def eval_data(k):",
"- if Lazy[k] != identity:",
"- l, r = k * sqrtA, (k + 1) * sqrtA",
"- for i in range(l, r):",
"- Data[i] = i - Lazy[k]",
"- Lazy[k] = identity",
"+import sys",
"+import numpy as np",
"-def update(s, t, x):",
"- for k in range(s // sqrtA, (t - 1) // sqrtA + 1):",
"- l, r = k * sqrtA, (k + 1) * sqrtA",
"- if s <= l and r <= t:",
"- Bucket_min[k] = l - x",
"- Lazy[k] = x",
"- else:",
"- eval_data(k)",
"- for i in range(max(l, s), min(r, t)):",
"- Data[i] = i - x",
"- Bucket_min[k] = min(Data[l:r])",
"+def solve(H, W, AB):",
"+ A = W + 1",
"+ identity = -(1 << 62)",
"+ sqrtA = 500",
"+ n_buckets = A // sqrtA + 1",
"+ Data = np.zeros(n_buckets * sqrtA, dtype=np.int64)",
"+ Data[0] = 1 << 30",
"+ Bucket_min = np.zeros(n_buckets, dtype=np.int64)",
"+ Lazy = np.full(n_buckets, identity, dtype=np.int64)",
"+",
"+ def eval_data(k):",
"+ if Lazy[k] != identity:",
"+ l, r = k * sqrtA, (k + 1) * sqrtA",
"+ for i in range(l, r):",
"+ Data[i] = i - Lazy[k]",
"+ Lazy[k] = identity",
"+",
"+ def update(s, t, x):",
"+ for k in range(s // sqrtA, (t - 1) // sqrtA + 1):",
"+ l, r = k * sqrtA, (k + 1) * sqrtA",
"+ if s <= l and r <= t:",
"+ Bucket_min[k] = l - x",
"+ Lazy[k] = x",
"+ else:",
"+ eval_data(k)",
"+ for i in range(max(l, s), min(r, t)):",
"+ Data[i] = i - x",
"+ Bucket_min[k] = Data[l:r].min()",
"+",
"+ def get_min(s, t):",
"+ res = 1 << 62",
"+ bl, br = s // sqrtA + 1, t // sqrtA",
"+ if bl > br:",
"+ eval_data(br)",
"+ return Data[s:t].min()",
"+ if bl < br:",
"+ res = Bucket_min[bl:br].min()",
"+ ll, rr = bl * sqrtA, br * sqrtA",
"+ if s < ll:",
"+ eval_data(bl - 1)",
"+ mi = Data[s:ll].min()",
"+ if res > mi:",
"+ res = mi",
"+ if rr < t:",
"+ eval_data(br)",
"+ mi = Data[rr:t].min()",
"+ if res > mi:",
"+ res = mi",
"+ return res",
"+",
"+ Ans = np.zeros(H, dtype=np.int64)",
"+ for i in range(H):",
"+ a, b = AB[i]",
"+ update(a, b + 1, a - 1 - get_min(a - 1, a))",
"+ ans = get_min(1, W + 1)",
"+ Ans[i] = ans + i + 1 if ans < 1 << 25 else -1",
"+ return Ans",
"-def get_min(s, t):",
"- res = 1 << 62",
"- bl, br = s // sqrtA + 1, t // sqrtA",
"- if bl > br:",
"- eval_data(br)",
"- return min(Data[s:t])",
"- if bl < br:",
"- res = min(Bucket_min[bl:br])",
"- ll, rr = bl * sqrtA, br * sqrtA",
"- if s < ll:",
"- eval_data(bl - 1)",
"- mi = min(Data[s:ll])",
"- if res > mi:",
"- res = mi",
"- if rr < t:",
"- eval_data(br)",
"- mi = min(Data[rr:t])",
"- if res > mi:",
"- res = mi",
"- return res",
"+numba_compile([[solve, \"i8[:](i8,i8,i8[:,:])\"]])",
"-Ans = []",
"-for i, (a, b) in enumerate(AB, 1):",
"- update(a, b + 1, a - 1 - get_min(a - 1, a))",
"- ans = get_min(1, W + 1)",
"- Ans.append(ans + i if ans < 1 << 25 else -1)",
"-print((\"\\n\".join(map(str, Ans))))",
"+def main():",
"+ H, W = map(int, sys.stdin.buffer.readline().split())",
"+ AB = np.array(sys.stdin.buffer.read().split(), dtype=np.int64).reshape(H, 2)",
"+ Ans = solve(H, W, AB)",
"+ print(\"\\n\".join(map(str, Ans.tolist())))",
"+",
"+",
"+main()"
] | false
| 0.04417
| 0.27979
| 0.157867
|
[
"s231234324",
"s428222815"
] |
u646336881
|
p02681
|
python
|
s286859398
|
s678710997
| 186
| 110
| 70,304
| 70,292
|
Accepted
|
Accepted
| 40.86
|
#!/usr/bin/env python3
# Generated by https://github.com/kyuridenamida/atcoder-tools
from typing import *
import itertools
import math
import sys
INF = float('inf')
YES = "Yes" # type: str
NO = "No" # type: str
def solve(S: str, T: str):
return [NO, YES][len(S)+1 == len(T) and S == T[:-1]]
def main():
sys.setrecursionlimit(10 ** 6)
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
S = next(tokens) # type: str
T = next(tokens) # type: str
print((solve(S, T)))
if __name__ == '__main__':
main()
|
#!/usr/bin/env python3
# Generated by https://github.com/kyuridenamida/atcoder-tools
from typing import *
import itertools
import math
import sys
INF = float('inf')
YES = "Yes" # type: str
NO = "No" # type: str
def solve(S: str, T: str):
return [NO, YES][S == T[:-1]]
def main():
sys.setrecursionlimit(10 ** 6)
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
S = next(tokens) # type: str
T = next(tokens) # type: str
print((solve(S, T)))
if __name__ == '__main__':
main()
| 32
| 32
| 665
| 642
|
#!/usr/bin/env python3
# Generated by https://github.com/kyuridenamida/atcoder-tools
from typing import *
import itertools
import math
import sys
INF = float("inf")
YES = "Yes" # type: str
NO = "No" # type: str
def solve(S: str, T: str):
return [NO, YES][len(S) + 1 == len(T) and S == T[:-1]]
def main():
sys.setrecursionlimit(10**6)
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
S = next(tokens) # type: str
T = next(tokens) # type: str
print((solve(S, T)))
if __name__ == "__main__":
main()
|
#!/usr/bin/env python3
# Generated by https://github.com/kyuridenamida/atcoder-tools
from typing import *
import itertools
import math
import sys
INF = float("inf")
YES = "Yes" # type: str
NO = "No" # type: str
def solve(S: str, T: str):
return [NO, YES][S == T[:-1]]
def main():
sys.setrecursionlimit(10**6)
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
S = next(tokens) # type: str
T = next(tokens) # type: str
print((solve(S, T)))
if __name__ == "__main__":
main()
| false
| 0
|
[
"- return [NO, YES][len(S) + 1 == len(T) and S == T[:-1]]",
"+ return [NO, YES][S == T[:-1]]"
] | false
| 0.038336
| 0.038769
| 0.98883
|
[
"s286859398",
"s678710997"
] |
u260980560
|
p01101
|
python
|
s894927988
|
s079791112
| 1,350
| 50
| 7,680
| 7,764
|
Accepted
|
Accepted
| 96.3
|
while 1:
n, m = list(map(int, input().split()))
if n == m == 0:
break
*A,=list(map(int, input().split()))
s=0
for i in range(n):
for j in range(i):
if s<A[i]+A[j]<=m:
s = A[i]+A[j]
print((s or"NONE"))
|
while 1:
n, m = list(map(int, input().split()))
if n == m == 0:
break
A=sorted(map(int, input().split()))
def f():
j = n-1
yield 0
for i in range(n):
while j >= 0 and m < A[i]+A[j]:
j -= 1
if j <= i:
break
if j >= 0:
yield A[i]+A[j]
print((max(f()) or"NONE"))
| 11
| 16
| 264
| 402
|
while 1:
n, m = list(map(int, input().split()))
if n == m == 0:
break
(*A,) = list(map(int, input().split()))
s = 0
for i in range(n):
for j in range(i):
if s < A[i] + A[j] <= m:
s = A[i] + A[j]
print((s or "NONE"))
|
while 1:
n, m = list(map(int, input().split()))
if n == m == 0:
break
A = sorted(map(int, input().split()))
def f():
j = n - 1
yield 0
for i in range(n):
while j >= 0 and m < A[i] + A[j]:
j -= 1
if j <= i:
break
if j >= 0:
yield A[i] + A[j]
print((max(f()) or "NONE"))
| false
| 31.25
|
[
"- (*A,) = list(map(int, input().split()))",
"- s = 0",
"- for i in range(n):",
"- for j in range(i):",
"- if s < A[i] + A[j] <= m:",
"- s = A[i] + A[j]",
"- print((s or \"NONE\"))",
"+ A = sorted(map(int, input().split()))",
"+",
"+ def f():",
"+ j = n - 1",
"+ yield 0",
"+ for i in range(n):",
"+ while j >= 0 and m < A[i] + A[j]:",
"+ j -= 1",
"+ if j <= i:",
"+ break",
"+ if j >= 0:",
"+ yield A[i] + A[j]",
"+",
"+ print((max(f()) or \"NONE\"))"
] | false
| 0.145925
| 0.036759
| 3.969825
|
[
"s894927988",
"s079791112"
] |
u968404618
|
p02619
|
python
|
s405511903
|
s471529054
| 38
| 32
| 9,268
| 9,324
|
Accepted
|
Accepted
| 15.79
|
D = int(eval(input()))
C = list(map(int, input().split()))
S = [list(map(int, input().split())) for _ in range(D)]
T = [int(eval(input()))-1 for _ in range(D)]
last = [0] * 26
score = 0
for d in range(D):
v = T[d]
score += S[d][v]
for i in range(26):
if i == v:
last[i] = 0
else:
last[i] += 1
score -= C[i] * last[i]
print(score)
|
d = int(eval(input()))
C = list(map(int, input().split()))
S = [list(map(int, input().split())) for _ in range(d)]
T = [int(eval(input())) for _ in range(d)]
last = [0] * 26
score = 0
for i, (s, t) in enumerate(zip(S, T), 1):
score += s[t-1]
last[t-1] = i
for j in range(26):
score -= C[j] * (i - last[j])
print(score)
| 17
| 15
| 398
| 351
|
D = int(eval(input()))
C = list(map(int, input().split()))
S = [list(map(int, input().split())) for _ in range(D)]
T = [int(eval(input())) - 1 for _ in range(D)]
last = [0] * 26
score = 0
for d in range(D):
v = T[d]
score += S[d][v]
for i in range(26):
if i == v:
last[i] = 0
else:
last[i] += 1
score -= C[i] * last[i]
print(score)
|
d = int(eval(input()))
C = list(map(int, input().split()))
S = [list(map(int, input().split())) for _ in range(d)]
T = [int(eval(input())) for _ in range(d)]
last = [0] * 26
score = 0
for i, (s, t) in enumerate(zip(S, T), 1):
score += s[t - 1]
last[t - 1] = i
for j in range(26):
score -= C[j] * (i - last[j])
print(score)
| false
| 11.764706
|
[
"-D = int(eval(input()))",
"+d = int(eval(input()))",
"-S = [list(map(int, input().split())) for _ in range(D)]",
"-T = [int(eval(input())) - 1 for _ in range(D)]",
"+S = [list(map(int, input().split())) for _ in range(d)]",
"+T = [int(eval(input())) for _ in range(d)]",
"-for d in range(D):",
"- v = T[d]",
"- score += S[d][v]",
"- for i in range(26):",
"- if i == v:",
"- last[i] = 0",
"- else:",
"- last[i] += 1",
"- score -= C[i] * last[i]",
"+for i, (s, t) in enumerate(zip(S, T), 1):",
"+ score += s[t - 1]",
"+ last[t - 1] = i",
"+ for j in range(26):",
"+ score -= C[j] * (i - last[j])"
] | false
| 0.070996
| 0.105378
| 0.673726
|
[
"s405511903",
"s471529054"
] |
u489762173
|
p02995
|
python
|
s459583966
|
s065397916
| 41
| 17
| 5,372
| 3,064
|
Accepted
|
Accepted
| 58.54
|
import sys
input = sys.stdin.readline
import fractions
def main():
A, B, C, D = list(map(int, input().split()))
Aone = A - 1
CDlcm = int(C / fractions.gcd(C, D) * D)
Bc = B // C
Bd = B // D
Blcm = B // CDlcm
Bdec = B - Bc - Bd + Blcm
# print(Bc,Bd,Blcm)
Ac = Aone // C
Ad = Aone // D
Alcm = Aone // CDlcm
Adec = Aone - Ac - Ad + Alcm
# print(Ac,Ad,Alcm)
print((Bdec - Adec))
main()
|
import sys
def gcd(a, b):
if a < b:
a, b = b, a
while b:
a, b = b, a % b
return a
def lcm(a, b):
return a * b // (gcd(a, b))
def main():
A, B, C, D = list(map(int, input().split()))
Aone = A - 1
CDlcm = lcm(C, D)
Bc = B // C
Bd = B // D
Blcm = B // CDlcm
Bdec = B - Bc - Bd + Blcm
# print(Bc,Bd,Blcm)
Ac = Aone // C
Ad = Aone // D
Alcm = Aone // CDlcm
Adec = Aone - Ac - Ad + Alcm
# print(Ac,Ad,Alcm)
print((Bdec - Adec))
main()
| 28
| 39
| 464
| 572
|
import sys
input = sys.stdin.readline
import fractions
def main():
A, B, C, D = list(map(int, input().split()))
Aone = A - 1
CDlcm = int(C / fractions.gcd(C, D) * D)
Bc = B // C
Bd = B // D
Blcm = B // CDlcm
Bdec = B - Bc - Bd + Blcm
# print(Bc,Bd,Blcm)
Ac = Aone // C
Ad = Aone // D
Alcm = Aone // CDlcm
Adec = Aone - Ac - Ad + Alcm
# print(Ac,Ad,Alcm)
print((Bdec - Adec))
main()
|
import sys
def gcd(a, b):
if a < b:
a, b = b, a
while b:
a, b = b, a % b
return a
def lcm(a, b):
return a * b // (gcd(a, b))
def main():
A, B, C, D = list(map(int, input().split()))
Aone = A - 1
CDlcm = lcm(C, D)
Bc = B // C
Bd = B // D
Blcm = B // CDlcm
Bdec = B - Bc - Bd + Blcm
# print(Bc,Bd,Blcm)
Ac = Aone // C
Ad = Aone // D
Alcm = Aone // CDlcm
Adec = Aone - Ac - Ad + Alcm
# print(Ac,Ad,Alcm)
print((Bdec - Adec))
main()
| false
| 28.205128
|
[
"-input = sys.stdin.readline",
"-import fractions",
"+",
"+def gcd(a, b):",
"+ if a < b:",
"+ a, b = b, a",
"+ while b:",
"+ a, b = b, a % b",
"+ return a",
"+",
"+",
"+def lcm(a, b):",
"+ return a * b // (gcd(a, b))",
"- CDlcm = int(C / fractions.gcd(C, D) * D)",
"+ CDlcm = lcm(C, D)"
] | false
| 0.045016
| 0.03384
| 1.330287
|
[
"s459583966",
"s065397916"
] |
u852690916
|
p02777
|
python
|
s916171576
|
s987447471
| 180
| 17
| 38,384
| 3,060
|
Accepted
|
Accepted
| 90.56
|
S,T=input().split()
A,B=list(map(int, input().split()))
U=eval(input())
if S==U:
print((A-1,B))
else:
print((A,B-1))
|
S,T=input().split()
A,B=list(map(int, input().split()))
U=eval(input())
A-=1 if S==U else 0
B-=1 if T==U else 0
print((A,B))
| 8
| 6
| 116
| 115
|
S, T = input().split()
A, B = list(map(int, input().split()))
U = eval(input())
if S == U:
print((A - 1, B))
else:
print((A, B - 1))
|
S, T = input().split()
A, B = list(map(int, input().split()))
U = eval(input())
A -= 1 if S == U else 0
B -= 1 if T == U else 0
print((A, B))
| false
| 25
|
[
"-if S == U:",
"- print((A - 1, B))",
"-else:",
"- print((A, B - 1))",
"+A -= 1 if S == U else 0",
"+B -= 1 if T == U else 0",
"+print((A, B))"
] | false
| 0.112096
| 0.035394
| 3.167082
|
[
"s916171576",
"s987447471"
] |
u480138356
|
p03283
|
python
|
s189737861
|
s744859742
| 2,498
| 1,333
| 15,064
| 15,256
|
Accepted
|
Accepted
| 46.64
|
# import sys
import numpy as np
# input = sys.stdin.readline
def main():
N, M, Q = list(map(int, input().split()))
check = np.zeros((N+1, N+1))
for i in range(M):
l, r = list(map(int, input().split()))
check[r][l] += 1
# print(check)
for i in range(1, N+1):
check[i] += check[i-1]
for i in range(1, N+1):
check[:,i] += check[:,i-1]
# print(check)
for i in range(Q):
p, q = list(map(int, input().split()))
print((int(check[q][q] - check[q][p-1] - check[p-1][q] + check[p-1][p-1])))
if __name__ == "__main__":
main()
|
import sys
import numpy as np
input = sys.stdin.readline
def main():
N, M, Q = list(map(int, input().split()))
check = np.zeros((N+1, N+1))
for i in range(M):
l, r = list(map(int, input().split()))
check[r][l] += 1
# print(check)
for i in range(1, N+1):
check[i] += check[i-1]
for i in range(1, N+1):
check[:,i] += check[:,i-1]
# print(check)
for i in range(Q):
p, q = list(map(int, input().split()))
print((int(check[q][q] - check[q][p-1] - check[p-1][q] + check[p-1][p-1])))
if __name__ == "__main__":
main()
| 26
| 26
| 610
| 606
|
# import sys
import numpy as np
# input = sys.stdin.readline
def main():
N, M, Q = list(map(int, input().split()))
check = np.zeros((N + 1, N + 1))
for i in range(M):
l, r = list(map(int, input().split()))
check[r][l] += 1
# print(check)
for i in range(1, N + 1):
check[i] += check[i - 1]
for i in range(1, N + 1):
check[:, i] += check[:, i - 1]
# print(check)
for i in range(Q):
p, q = list(map(int, input().split()))
print(
(int(check[q][q] - check[q][p - 1] - check[p - 1][q] + check[p - 1][p - 1]))
)
if __name__ == "__main__":
main()
|
import sys
import numpy as np
input = sys.stdin.readline
def main():
N, M, Q = list(map(int, input().split()))
check = np.zeros((N + 1, N + 1))
for i in range(M):
l, r = list(map(int, input().split()))
check[r][l] += 1
# print(check)
for i in range(1, N + 1):
check[i] += check[i - 1]
for i in range(1, N + 1):
check[:, i] += check[:, i - 1]
# print(check)
for i in range(Q):
p, q = list(map(int, input().split()))
print(
(int(check[q][q] - check[q][p - 1] - check[p - 1][q] + check[p - 1][p - 1]))
)
if __name__ == "__main__":
main()
| false
| 0
|
[
"-# import sys",
"+import sys",
"-# input = sys.stdin.readline",
"+input = sys.stdin.readline",
"+",
"+"
] | false
| 0.279296
| 1.113632
| 0.250798
|
[
"s189737861",
"s744859742"
] |
u116038906
|
p02780
|
python
|
s915508625
|
s955976052
| 201
| 163
| 29,764
| 32,640
|
Accepted
|
Accepted
| 18.91
|
# 初期入力
N,K = (int(x) for x in input().split(" "))
A = list(map(int, input().split()))
# １からnまでの和 S_n = n*(n+1)/2 さいころの期待値は S_n /n
kitaiti = [ (i+1)/2 for i in A ]
# N個のサイコロの期待値の累積和 S
S = [0] * (N +1)
#S[0] = kitaiti[0]
#S =[0]
# S[0] = 0
for i in range(1,N +1):
S[i] = S[i-1] + kitaiti[i-1]
# 隣接するK個の期待値の和 S_K
S_K = []
for i,v in enumerate(S[:(-1)*K ]):
S_K.append( S[i + K ] - S[i] )
"""
print(kitaiti)
print(S)
print(S_K)
"""
print((max(S_K)))
|
# 初期入力
#import numpy as np
import sys
input = sys.stdin.readline
N,K = (int(i) for i in input().split())
p = list(map(int, input().split()))
expected_value =[(i+1)/2 for i in p] #各さいころの期待値
#隣接する数列の和
adjacent_sum =[0]*N
adjacent_sum[0] =sum(expected_value[:K])
ans =[0]*N
ans[0] =adjacent_sum[0]
for i in range(1,N-K+1):
adjacent_sum[i] =adjacent_sum[i-1] -expected_value[i-1] +expected_value[i+K-1]
ans[i] =adjacent_sum[i]
print((max(ans)))
| 25
| 18
| 478
| 466
|
# 初期入力
N, K = (int(x) for x in input().split(" "))
A = list(map(int, input().split()))
# １からnまでの和 S_n = n*(n+1)/2 さいころの期待値は S_n /n
kitaiti = [(i + 1) / 2 for i in A]
# N個のサイコロの期待値の累積和 S
S = [0] * (N + 1)
# S[0] = kitaiti[0]
# S =[0]
# S[0] = 0
for i in range(1, N + 1):
S[i] = S[i - 1] + kitaiti[i - 1]
# 隣接するK個の期待値の和 S_K
S_K = []
for i, v in enumerate(S[: (-1) * K]):
S_K.append(S[i + K] - S[i])
"""
print(kitaiti)
print(S)
print(S_K)
"""
print((max(S_K)))
|
# 初期入力
# import numpy as np
import sys
input = sys.stdin.readline
N, K = (int(i) for i in input().split())
p = list(map(int, input().split()))
expected_value = [(i + 1) / 2 for i in p] # 各さいころの期待値
# 隣接する数列の和
adjacent_sum = [0] * N
adjacent_sum[0] = sum(expected_value[:K])
ans = [0] * N
ans[0] = adjacent_sum[0]
for i in range(1, N - K + 1):
adjacent_sum[i] = (
adjacent_sum[i - 1] - expected_value[i - 1] + expected_value[i + K - 1]
)
ans[i] = adjacent_sum[i]
print((max(ans)))
| false
| 28
|
[
"-N, K = (int(x) for x in input().split(\" \"))",
"-A = list(map(int, input().split()))",
"-# １からnまでの和 S_n = n*(n+1)/2 さいころの期待値は S_n /n",
"-kitaiti = [(i + 1) / 2 for i in A]",
"-# N個のサイコロの期待値の累積和 S",
"-S = [0] * (N + 1)",
"-# S[0] = kitaiti[0]",
"-# S =[0]",
"-# S[0] = 0",
"-for i in range(1, N + 1):",
"- S[i] = S[i - 1] + kitaiti[i - 1]",
"-# 隣接するK個の期待値の和 S_K",
"-S_K = []",
"-for i, v in enumerate(S[: (-1) * K]):",
"- S_K.append(S[i + K] - S[i])",
"-\"\"\"",
"-print(kitaiti)",
"-print(S)",
"-print(S_K)",
"-\"\"\"",
"-print((max(S_K)))",
"+# import numpy as np",
"+import sys",
"+",
"+input = sys.stdin.readline",
"+N, K = (int(i) for i in input().split())",
"+p = list(map(int, input().split()))",
"+expected_value = [(i + 1) / 2 for i in p] # 各さいころの期待値",
"+# 隣接する数列の和",
"+adjacent_sum = [0] * N",
"+adjacent_sum[0] = sum(expected_value[:K])",
"+ans = [0] * N",
"+ans[0] = adjacent_sum[0]",
"+for i in range(1, N - K + 1):",
"+ adjacent_sum[i] = (",
"+ adjacent_sum[i - 1] - expected_value[i - 1] + expected_value[i + K - 1]",
"+ )",
"+ ans[i] = adjacent_sum[i]",
"+print((max(ans)))"
] | false
| 0.11714
| 0.113128
| 1.035463
|
[
"s915508625",
"s955976052"
] |
u960080897
|
p02579
|
python
|
s131859250
|
s712541213
| 835
| 770
| 119,912
| 108,676
|
Accepted
|
Accepted
| 7.78
|
# Date [ 2020-08-22 21:07:07 ]
# Problem [ d.py ]
# Author Koki_tkg
import sys; from decimal import Decimal
import math; from itertools import combinations, product
import bisect; from collections import Counter, deque, defaultdict
# sys.setrecursionlimit(10 ** 6)
MOD = 10 ** 9 + 7
INF = 10 ** 9
PI = 3.14159265358979323846
def read_str(): return sys.stdin.readline().strip()
def read_int(): return int(sys.stdin.readline().strip())
def read_ints(): return list(map(int, sys.stdin.readline().strip().split()))
def read_str_list(): return list(sys.stdin.readline().strip().split())
def read_int_list(): return list(map(int, sys.stdin.readline().strip().split()))
def lcm(a: int, b: int) -> int: return (a * b) // math.gcd(a, b)
import numpy as np
from numba import i8, njit, u1, b1
from heapq import heappop, heappush
@njit(i8(b1[:,:], i8, i8, i8, i8), cache=True)
def solve(grid, ch, cw, dh, dw):
h, w = grid.shape
dist = np.full((h, w), INF, dtype=np.int64)
dist[ch][cw] = 0
que = [(0, ch, cw)]
while que:
cnt, y, x = heappop(que)
if y == dh and x == dw:
break
for dy in range(-2, 3):
for dx in range(-2, 3):
if dx == 0 and dy == 0:
continue
if abs(dx) == 2 or abs(dy) == 2 or (abs(dx) == 1 and abs(dy) == 1):
warp = 1
else:
warp = 0
nx, ny = x + dx, y + dy
if nx < 0 or nx >= w or ny < 0 or ny >= h or grid[ny][nx]:
continue
if dist[ny][nx] > cnt + warp:
dist[ny][nx] = cnt + warp
heappush(que, (cnt + warp, ny, nx))
if dist[dh][dw] == INF:
return - 1
else:
return dist[dh][dw]
def Main():
H, W = read_ints()
ch, cw = read_ints(); ch -= 1; cw -= 1
dh, dw = read_ints(); dh -= 1; dw -= 1
grid = np.array([[g == '#' for g in read_str()] for _ in range(H)])
print((solve(grid, ch, cw, dh, dw)))
def cc_export(config):
from numba.pycc import CC
cc = CC('my_module')
for func, signature in config:
vars()[func.__name__] = njit(signature)(func)
cc.export(func.__name__, signature)(func)
cc.compile()
if __name__ == '__main__':
Main()
|
# Date [ 2020-08-22 21:07:07 ]
# Problem [ d.py ]
# Author Koki_tkg
import sys; from decimal import Decimal
import math; from itertools import combinations, product
import bisect; from collections import Counter, deque, defaultdict
# sys.setrecursionlimit(10 ** 6)
MOD = 10 ** 9 + 7
INF = 10 ** 9
PI = 3.14159265358979323846
def read_str(): return sys.stdin.readline().strip()
def read_int(): return int(sys.stdin.readline().strip())
def read_ints(): return list(map(int, sys.stdin.readline().strip().split()))
def read_str_list(): return list(sys.stdin.readline().strip().split())
def read_int_list(): return list(map(int, sys.stdin.readline().strip().split()))
def lcm(a: int, b: int) -> int: return (a * b) // math.gcd(a, b)
import numpy as np
from numba import i8, njit, u1, b1
from heapq import heappop, heappush
#@njit(i8(b1[:,:], i8, i8, i8, i8), cache=True)
def solve(grid, ch, cw, dh, dw):
h, w = grid.shape
dist = np.full((h, w), INF, dtype=np.int64)
dist[ch][cw] = 0
que = [(0, ch, cw)]
while que:
cnt, y, x = heappop(que)
if y == dh and x == dw:
break
for dy in range(-2, 3):
for dx in range(-2, 3):
if dx == 0 and dy == 0:
continue
if abs(dx) == 2 or abs(dy) == 2 or (abs(dx) == 1 and abs(dy) == 1):
warp = 1
else:
warp = 0
nx, ny = x + dx, y + dy
if nx < 0 or nx >= w or ny < 0 or ny >= h or grid[ny][nx]:
continue
if dist[ny][nx] > cnt + warp:
dist[ny][nx] = cnt + warp
heappush(que, (cnt + warp, ny, nx))
if dist[dh][dw] == INF:
return - 1
else:
return dist[dh][dw]
def Main():
H, W = read_ints()
ch, cw = read_ints(); ch -= 1; cw -= 1
dh, dw = read_ints(); dh -= 1; dw -= 1
grid = np.array([[g == '#' for g in read_str()] for _ in range(H)])
print((solve(grid, ch, cw, dh, dw)))
def cc_export():
from numba.pycc import CC
cc = CC('my_module')
cc.export('solve','(b1[:,:], i8, i8, i8, i8,)')(solve)
cc.compile()
if __name__ == '__main__':
if sys.argv[-1] == 'ONLINE_JUDGE':
cc_export()
exit()
from my_module import solve
Main()
| 82
| 84
| 2,437
| 2,460
|
# Date [ 2020-08-22 21:07:07 ]
# Problem [ d.py ]
# Author Koki_tkg
import sys
from decimal import Decimal
import math
from itertools import combinations, product
import bisect
from collections import Counter, deque, defaultdict
# sys.setrecursionlimit(10 ** 6)
MOD = 10**9 + 7
INF = 10**9
PI = 3.14159265358979323846
def read_str():
return sys.stdin.readline().strip()
def read_int():
return int(sys.stdin.readline().strip())
def read_ints():
return list(map(int, sys.stdin.readline().strip().split()))
def read_str_list():
return list(sys.stdin.readline().strip().split())
def read_int_list():
return list(map(int, sys.stdin.readline().strip().split()))
def lcm(a: int, b: int) -> int:
return (a * b) // math.gcd(a, b)
import numpy as np
from numba import i8, njit, u1, b1
from heapq import heappop, heappush
@njit(i8(b1[:, :], i8, i8, i8, i8), cache=True)
def solve(grid, ch, cw, dh, dw):
h, w = grid.shape
dist = np.full((h, w), INF, dtype=np.int64)
dist[ch][cw] = 0
que = [(0, ch, cw)]
while que:
cnt, y, x = heappop(que)
if y == dh and x == dw:
break
for dy in range(-2, 3):
for dx in range(-2, 3):
if dx == 0 and dy == 0:
continue
if abs(dx) == 2 or abs(dy) == 2 or (abs(dx) == 1 and abs(dy) == 1):
warp = 1
else:
warp = 0
nx, ny = x + dx, y + dy
if nx < 0 or nx >= w or ny < 0 or ny >= h or grid[ny][nx]:
continue
if dist[ny][nx] > cnt + warp:
dist[ny][nx] = cnt + warp
heappush(que, (cnt + warp, ny, nx))
if dist[dh][dw] == INF:
return -1
else:
return dist[dh][dw]
def Main():
H, W = read_ints()
ch, cw = read_ints()
ch -= 1
cw -= 1
dh, dw = read_ints()
dh -= 1
dw -= 1
grid = np.array([[g == "#" for g in read_str()] for _ in range(H)])
print((solve(grid, ch, cw, dh, dw)))
def cc_export(config):
from numba.pycc import CC
cc = CC("my_module")
for func, signature in config:
vars()[func.__name__] = njit(signature)(func)
cc.export(func.__name__, signature)(func)
cc.compile()
if __name__ == "__main__":
Main()
|
# Date [ 2020-08-22 21:07:07 ]
# Problem [ d.py ]
# Author Koki_tkg
import sys
from decimal import Decimal
import math
from itertools import combinations, product
import bisect
from collections import Counter, deque, defaultdict
# sys.setrecursionlimit(10 ** 6)
MOD = 10**9 + 7
INF = 10**9
PI = 3.14159265358979323846
def read_str():
return sys.stdin.readline().strip()
def read_int():
return int(sys.stdin.readline().strip())
def read_ints():
return list(map(int, sys.stdin.readline().strip().split()))
def read_str_list():
return list(sys.stdin.readline().strip().split())
def read_int_list():
return list(map(int, sys.stdin.readline().strip().split()))
def lcm(a: int, b: int) -> int:
return (a * b) // math.gcd(a, b)
import numpy as np
from numba import i8, njit, u1, b1
from heapq import heappop, heappush
# @njit(i8(b1[:,:], i8, i8, i8, i8), cache=True)
def solve(grid, ch, cw, dh, dw):
h, w = grid.shape
dist = np.full((h, w), INF, dtype=np.int64)
dist[ch][cw] = 0
que = [(0, ch, cw)]
while que:
cnt, y, x = heappop(que)
if y == dh and x == dw:
break
for dy in range(-2, 3):
for dx in range(-2, 3):
if dx == 0 and dy == 0:
continue
if abs(dx) == 2 or abs(dy) == 2 or (abs(dx) == 1 and abs(dy) == 1):
warp = 1
else:
warp = 0
nx, ny = x + dx, y + dy
if nx < 0 or nx >= w or ny < 0 or ny >= h or grid[ny][nx]:
continue
if dist[ny][nx] > cnt + warp:
dist[ny][nx] = cnt + warp
heappush(que, (cnt + warp, ny, nx))
if dist[dh][dw] == INF:
return -1
else:
return dist[dh][dw]
def Main():
H, W = read_ints()
ch, cw = read_ints()
ch -= 1
cw -= 1
dh, dw = read_ints()
dh -= 1
dw -= 1
grid = np.array([[g == "#" for g in read_str()] for _ in range(H)])
print((solve(grid, ch, cw, dh, dw)))
def cc_export():
from numba.pycc import CC
cc = CC("my_module")
cc.export("solve", "(b1[:,:], i8, i8, i8, i8,)")(solve)
cc.compile()
if __name__ == "__main__":
if sys.argv[-1] == "ONLINE_JUDGE":
cc_export()
exit()
from my_module import solve
Main()
| false
| 2.380952
|
[
"-",
"-@njit(i8(b1[:, :], i8, i8, i8, i8), cache=True)",
"+# @njit(i8(b1[:,:], i8, i8, i8, i8), cache=True)",
"-def cc_export(config):",
"+def cc_export():",
"- for func, signature in config:",
"- vars()[func.__name__] = njit(signature)(func)",
"- cc.export(func.__name__, signature)(func)",
"+ cc.export(\"solve\", \"(b1[:,:], i8, i8, i8, i8,)\")(solve)",
"+ if sys.argv[-1] == \"ONLINE_JUDGE\":",
"+ cc_export()",
"+ exit()",
"+ from my_module import solve",
"+"
] | false
| 0.263099
| 0.313068
| 0.840391
|
[
"s131859250",
"s712541213"
] |
u266874640
|
p02831
|
python
|
s770336809
|
s291817977
| 53
| 35
| 5,560
| 5,048
|
Accepted
|
Accepted
| 33.96
|
import fractions
A, B = list(map(int, input().split()))
print((A*B // fractions.gcd(A, B)))
|
import fractions
A, B = list(map(int,input().split()))
def lcm(A,B):
return (A*B) // fractions.gcd(A,B)
print((lcm(A,B)))
| 3
| 5
| 85
| 122
|
import fractions
A, B = list(map(int, input().split()))
print((A * B // fractions.gcd(A, B)))
|
import fractions
A, B = list(map(int, input().split()))
def lcm(A, B):
return (A * B) // fractions.gcd(A, B)
print((lcm(A, B)))
| false
| 40
|
[
"-print((A * B // fractions.gcd(A, B)))",
"+",
"+",
"+def lcm(A, B):",
"+ return (A * B) // fractions.gcd(A, B)",
"+",
"+",
"+print((lcm(A, B)))"
] | false
| 0.107555
| 0.108661
| 0.989822
|
[
"s770336809",
"s291817977"
] |
u814781830
|
p02695
|
python
|
s984331042
|
s035750894
| 369
| 274
| 77,772
| 75,668
|
Accepted
|
Accepted
| 25.75
|
N, M, Q = list(map(int, input().split()))
abcd = [list(map(int, input().split())) for _ in range(Q)]
def calc(p):
ret = 0
# 各条件を満たしていれば、dを加算していく
for a, b, c, d in abcd:
if p[b-1] - p[a-1] == c:
ret += d
return ret
ans = [0]
def dfs(s):
if len(s) == N:
ans[0] = max(ans[0], calc(s))
return
for i in range(s[-1],M+1):
dfs(s+[i])
for i in range(1, M+1):
dfs([i])
print((ans[0]))
|
N, M, Q = list(map(int, input().split()))
abcd = [tuple(map(int, input().split())) for _ in range(Q)]
ans = 0
def calc(p):
ret = 0
for a, b, c, d in abcd:
a, b = a-1, b-1
if p[b] - p[a] == c:
ret += d
return ret
def dfs(a, d):
global ans
if d == N:
ans = max(ans, calc(a))
return
for i in range(a[-1], M+1):
dfs(a+[i], d+1)
for i in range(1, M+1):
dfs([i], 1)
print(ans)
| 24
| 23
| 468
| 470
|
N, M, Q = list(map(int, input().split()))
abcd = [list(map(int, input().split())) for _ in range(Q)]
def calc(p):
ret = 0
# 各条件を満たしていれば、dを加算していく
for a, b, c, d in abcd:
if p[b - 1] - p[a - 1] == c:
ret += d
return ret
ans = [0]
def dfs(s):
if len(s) == N:
ans[0] = max(ans[0], calc(s))
return
for i in range(s[-1], M + 1):
dfs(s + [i])
for i in range(1, M + 1):
dfs([i])
print((ans[0]))
|
N, M, Q = list(map(int, input().split()))
abcd = [tuple(map(int, input().split())) for _ in range(Q)]
ans = 0
def calc(p):
ret = 0
for a, b, c, d in abcd:
a, b = a - 1, b - 1
if p[b] - p[a] == c:
ret += d
return ret
def dfs(a, d):
global ans
if d == N:
ans = max(ans, calc(a))
return
for i in range(a[-1], M + 1):
dfs(a + [i], d + 1)
for i in range(1, M + 1):
dfs([i], 1)
print(ans)
| false
| 4.166667
|
[
"-abcd = [list(map(int, input().split())) for _ in range(Q)]",
"+abcd = [tuple(map(int, input().split())) for _ in range(Q)]",
"+ans = 0",
"- # 各条件を満たしていれば、dを加算していく",
"- if p[b - 1] - p[a - 1] == c:",
"+ a, b = a - 1, b - 1",
"+ if p[b] - p[a] == c:",
"-ans = [0]",
"-",
"-",
"-def dfs(s):",
"- if len(s) == N:",
"- ans[0] = max(ans[0], calc(s))",
"+def dfs(a, d):",
"+ global ans",
"+ if d == N:",
"+ ans = max(ans, calc(a))",
"- for i in range(s[-1], M + 1):",
"- dfs(s + [i])",
"+ for i in range(a[-1], M + 1):",
"+ dfs(a + [i], d + 1)",
"- dfs([i])",
"-print((ans[0]))",
"+ dfs([i], 1)",
"+print(ans)"
] | false
| 0.007247
| 0.278487
| 0.026023
|
[
"s984331042",
"s035750894"
] |
u619144316
|
p02803
|
python
|
s641934359
|
s745994701
| 643
| 27
| 3,444
| 3,444
|
Accepted
|
Accepted
| 95.8
|
from collections import defaultdict,deque
H, W = list(map(int,input().split()))
MAP = []
for _ in range(H):
MAP.append(tuple(map(str,eval(input()))))
move = [[0,1],[0,-1],[1,0],[-1,0]]
MAX = 0
def bfs(s):
global MAX
stack = deque([])
stack.append(tuple(s))
depth =dict()
depth[tuple(s)] = 0
while stack:
v = stack.popleft()
for m in move:
a = tuple([v[0]+m[0], v[1] + m[1]])
if a[0] < H and a[0] >= 0 and a[1] < W and a[1] >= 0:
if MAP[a[0]][a[1]] == '.' and not a in depth:
stack.append(a)
depth[a] = depth[v] + 1
for d in list(depth.values()):
MAX = max(MAX,d)
for i in range(0,H):
for j in range(0,W):
if MAP[i][j] == '.':
bfs(tuple([i,j]))
print(MAX)
|
from collections import defaultdict,deque
H, W = list(map(int,input().split()))
MAP = []
for _ in range(H):
MAP.append(list(map(str,eval(input()))))
move = [[0,1],[0,-1],[1,0],[-1,0]]
def bfs(s):
MAX = 0
stack = deque([])
stack.append(tuple(s))
depth =dict()
depth[tuple(s)] = 0
goal = s
while stack:
v = stack.popleft()
for m in move:
a = tuple([v[0]+m[0], v[1] + m[1]])
if a[0] < H and a[0] >= 0 and a[1] < W and a[1] >= 0:
if MAP[a[0]][a[1]] == '.' and not a in depth:
stack.append(a)
depth[a] = depth[v] + 1
for k,d in list(depth.items()):
if MAX < d:
MAX = d
goal = k
return MAX, goal
for r in range(0,H):
if "." in MAP[r]:
start = [r, MAP[r].index(".")]
MAX, goal = bfs(tuple(start))
MAX, _ = bfs(tuple(goal))
print(MAX)
exit()
| 33
| 40
| 835
| 943
|
from collections import defaultdict, deque
H, W = list(map(int, input().split()))
MAP = []
for _ in range(H):
MAP.append(tuple(map(str, eval(input()))))
move = [[0, 1], [0, -1], [1, 0], [-1, 0]]
MAX = 0
def bfs(s):
global MAX
stack = deque([])
stack.append(tuple(s))
depth = dict()
depth[tuple(s)] = 0
while stack:
v = stack.popleft()
for m in move:
a = tuple([v[0] + m[0], v[1] + m[1]])
if a[0] < H and a[0] >= 0 and a[1] < W and a[1] >= 0:
if MAP[a[0]][a[1]] == "." and not a in depth:
stack.append(a)
depth[a] = depth[v] + 1
for d in list(depth.values()):
MAX = max(MAX, d)
for i in range(0, H):
for j in range(0, W):
if MAP[i][j] == ".":
bfs(tuple([i, j]))
print(MAX)
|
from collections import defaultdict, deque
H, W = list(map(int, input().split()))
MAP = []
for _ in range(H):
MAP.append(list(map(str, eval(input()))))
move = [[0, 1], [0, -1], [1, 0], [-1, 0]]
def bfs(s):
MAX = 0
stack = deque([])
stack.append(tuple(s))
depth = dict()
depth[tuple(s)] = 0
goal = s
while stack:
v = stack.popleft()
for m in move:
a = tuple([v[0] + m[0], v[1] + m[1]])
if a[0] < H and a[0] >= 0 and a[1] < W and a[1] >= 0:
if MAP[a[0]][a[1]] == "." and not a in depth:
stack.append(a)
depth[a] = depth[v] + 1
for k, d in list(depth.items()):
if MAX < d:
MAX = d
goal = k
return MAX, goal
for r in range(0, H):
if "." in MAP[r]:
start = [r, MAP[r].index(".")]
MAX, goal = bfs(tuple(start))
MAX, _ = bfs(tuple(goal))
print(MAX)
exit()
| false
| 17.5
|
[
"- MAP.append(tuple(map(str, eval(input()))))",
"+ MAP.append(list(map(str, eval(input()))))",
"-MAX = 0",
"- global MAX",
"+ MAX = 0",
"+ goal = s",
"- for d in list(depth.values()):",
"- MAX = max(MAX, d)",
"+ for k, d in list(depth.items()):",
"+ if MAX < d:",
"+ MAX = d",
"+ goal = k",
"+ return MAX, goal",
"-for i in range(0, H):",
"- for j in range(0, W):",
"- if MAP[i][j] == \".\":",
"- bfs(tuple([i, j]))",
"+for r in range(0, H):",
"+ if \".\" in MAP[r]:",
"+ start = [r, MAP[r].index(\".\")]",
"+MAX, goal = bfs(tuple(start))",
"+MAX, _ = bfs(tuple(goal))",
"+exit()"
] | false
| 0.122699
| 0.035615
| 3.445129
|
[
"s641934359",
"s745994701"
] |
u802963389
|
p03287
|
python
|
s408447672
|
s410423221
| 117
| 99
| 16,796
| 18,844
|
Accepted
|
Accepted
| 15.38
|
from collections import defaultdict
n, m = list(map(int, input().split()))
A = list(map(int, input().split()))
accum = [0] * (n + 1)
for i in range(n):
accum[i + 1] = accum[i] + A[i]
box = defaultdict(int)
for i in accum:
box[i % m] += 1
ans = 0
for v in list(box.values()):
ans += v * (v - 1) // 2
print(ans)
|
# D - Candy Distribution
# https://atcoder.jp/contests/abc105/tasks/abc105_d
from collections import Counter
n, m = list(map(int, input().split()))
A = list(map(int, input().split()))
accr = [0] * (n + 1)
for i in range(n):
accr[i + 1] = accr[i] + A[i]
li = [i % m for i in accr]
C = Counter(li)
ans = 0
for v in list(C.values()):
if v > 1:
ans += v * (v - 1) // 2
print(ans)
| 20
| 23
| 335
| 402
|
from collections import defaultdict
n, m = list(map(int, input().split()))
A = list(map(int, input().split()))
accum = [0] * (n + 1)
for i in range(n):
accum[i + 1] = accum[i] + A[i]
box = defaultdict(int)
for i in accum:
box[i % m] += 1
ans = 0
for v in list(box.values()):
ans += v * (v - 1) // 2
print(ans)
|
# D - Candy Distribution
# https://atcoder.jp/contests/abc105/tasks/abc105_d
from collections import Counter
n, m = list(map(int, input().split()))
A = list(map(int, input().split()))
accr = [0] * (n + 1)
for i in range(n):
accr[i + 1] = accr[i] + A[i]
li = [i % m for i in accr]
C = Counter(li)
ans = 0
for v in list(C.values()):
if v > 1:
ans += v * (v - 1) // 2
print(ans)
| false
| 13.043478
|
[
"-from collections import defaultdict",
"+# D - Candy Distribution",
"+# https://atcoder.jp/contests/abc105/tasks/abc105_d",
"+from collections import Counter",
"-accum = [0] * (n + 1)",
"+accr = [0] * (n + 1)",
"- accum[i + 1] = accum[i] + A[i]",
"-box = defaultdict(int)",
"-for i in accum:",
"- box[i % m] += 1",
"+ accr[i + 1] = accr[i] + A[i]",
"+li = [i % m for i in accr]",
"+C = Counter(li)",
"-for v in list(box.values()):",
"- ans += v * (v - 1) // 2",
"+for v in list(C.values()):",
"+ if v > 1:",
"+ ans += v * (v - 1) // 2"
] | false
| 0.03438
| 0.053611
| 0.64129
|
[
"s408447672",
"s410423221"
] |
u088552457
|
p03937
|
python
|
s182413469
|
s239975660
| 164
| 62
| 38,256
| 62,020
|
Accepted
|
Accepted
| 62.2
|
import sys
input = sys.stdin.readline
import collections
def main():
h, w = input_list()
masu = []
c = 0
for _ in range(h):
c += input().count('#')
if h + w - 1 == c:
print('Possible')
else:
print('Impossible')
def input_list():
return list(map(int, input().split()))
def input_list_str():
return list(map(str, input().split()))
if __name__ == "__main__":
main()
|
# import sys
# input = sys.stdin.readline
import itertools
# 持っているビスケットを叩き、1枚増やす
# ビスケット A枚を 1円に交換する
# 1円をビスケット B枚に交換する
def main():
h, w = input_list()
count = 0
for _ in range(h):
s = list(eval(input()))
count += s.count('#')
if h+w-1 == count:
print('Possible')
else:
print('Impossible')
def input_list():
return list(map(int, input().split()))
def input_list_str():
return list(map(str, input().split()))
if __name__ == "__main__":
main()
| 25
| 28
| 453
| 533
|
import sys
input = sys.stdin.readline
import collections
def main():
h, w = input_list()
masu = []
c = 0
for _ in range(h):
c += input().count("#")
if h + w - 1 == c:
print("Possible")
else:
print("Impossible")
def input_list():
return list(map(int, input().split()))
def input_list_str():
return list(map(str, input().split()))
if __name__ == "__main__":
main()
|
# import sys
# input = sys.stdin.readline
import itertools
# 持っているビスケットを叩き、1枚増やす
# ビスケット A枚を 1円に交換する
# 1円をビスケット B枚に交換する
def main():
h, w = input_list()
count = 0
for _ in range(h):
s = list(eval(input()))
count += s.count("#")
if h + w - 1 == count:
print("Possible")
else:
print("Impossible")
def input_list():
return list(map(int, input().split()))
def input_list_str():
return list(map(str, input().split()))
if __name__ == "__main__":
main()
| false
| 10.714286
|
[
"-import sys",
"+# import sys",
"+# input = sys.stdin.readline",
"+import itertools",
"-input = sys.stdin.readline",
"-import collections",
"-",
"-",
"+# 持っているビスケットを叩き、1枚増やす",
"+# ビスケット A枚を 1円に交換する",
"+# 1円をビスケット B枚に交換する",
"- masu = []",
"- c = 0",
"+ count = 0",
"- c += input().count(\"#\")",
"- if h + w - 1 == c:",
"+ s = list(eval(input()))",
"+ count += s.count(\"#\")",
"+ if h + w - 1 == count:"
] | false
| 0.042477
| 0.035695
| 1.189994
|
[
"s182413469",
"s239975660"
] |
u043048943
|
p03078
|
python
|
s851383304
|
s851606142
| 491
| 380
| 105,176
| 57,820
|
Accepted
|
Accepted
| 22.61
|
#coding:utf-8
import sys
sys.setrecursionlimit(2**31-1)
input = sys.stdin.readline
write = sys.stdout.write
LMIIS = lambda : list(map(int,input().split()))
II = lambda : int(input())
dbg = lambda *something : print(*something) if DEBUG is True else 0
DEBUG = True
def main():
X,Y,Z,K = LMIIS()
A = LMIIS()
B = LMIIS()
C = LMIIS()
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
ans = []
for ai in range(X):
for bi in range(Y):
if ai * bi > K:
break
for ci in range(Z):
if ai * bi * ci > K:
break
ans.append(A[ai]+B[bi]+C[ci])
ans.sort(reverse=True)
for i in range(K):
print(ans[i])
if __name__ == '__main__':
main()
|
#coding:utf-8
import sys
sys.setrecursionlimit(2**31-1)
input = sys.stdin.readline
write = sys.stdout.write
LMIIS = lambda : list(map(int,input().split()))
II = lambda : int(input())
dbg = lambda *something : print(*something) if DEBUG is True else 0
DEBUG = True
def main():
X,Y,Z,K = LMIIS()
A = LMIIS()
B = LMIIS()
C = LMIIS()
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
from heapq import heappush,heappop
from collections import defaultdict
d = defaultdict(lambda:False)
h = []
ai = bi = ci = 0
heappush(h,(-(A[ai]+B[bi]+C[ci]),ai,bi,ci))
d[(0,0,0)] = True
for _ in range(K):
v,ai,bi,ci = heappop(h)
print(-v)
if ai+1 < X and d[(ai+1,bi,ci)] == False:
heappush(h,(-(A[ai+1]+B[bi]+C[ci]),ai+1,bi,ci))
d[(ai+1,bi,ci)] = True
if bi+1 < Y and d[(ai,bi+1,ci)] == False:
heappush(h,(-(A[ai]+B[bi+1]+C[ci]),ai,bi+1,ci))
d[(ai,bi+1,ci)] = True
if ci+1 < Z and d[(ai,bi,ci+1)] == False:
heappush(h,(-(A[ai]+B[bi]+C[ci+1]),ai,bi,ci+1))
d[(ai,bi,ci+1)] = True
if __name__ == '__main__':
main()
| 40
| 46
| 862
| 1,246
|
# coding:utf-8
import sys
sys.setrecursionlimit(2**31 - 1)
input = sys.stdin.readline
write = sys.stdout.write
LMIIS = lambda: list(map(int, input().split()))
II = lambda: int(input())
dbg = lambda *something: print(*something) if DEBUG is True else 0
DEBUG = True
def main():
X, Y, Z, K = LMIIS()
A = LMIIS()
B = LMIIS()
C = LMIIS()
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
ans = []
for ai in range(X):
for bi in range(Y):
if ai * bi > K:
break
for ci in range(Z):
if ai * bi * ci > K:
break
ans.append(A[ai] + B[bi] + C[ci])
ans.sort(reverse=True)
for i in range(K):
print(ans[i])
if __name__ == "__main__":
main()
|
# coding:utf-8
import sys
sys.setrecursionlimit(2**31 - 1)
input = sys.stdin.readline
write = sys.stdout.write
LMIIS = lambda: list(map(int, input().split()))
II = lambda: int(input())
dbg = lambda *something: print(*something) if DEBUG is True else 0
DEBUG = True
def main():
X, Y, Z, K = LMIIS()
A = LMIIS()
B = LMIIS()
C = LMIIS()
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
from heapq import heappush, heappop
from collections import defaultdict
d = defaultdict(lambda: False)
h = []
ai = bi = ci = 0
heappush(h, (-(A[ai] + B[bi] + C[ci]), ai, bi, ci))
d[(0, 0, 0)] = True
for _ in range(K):
v, ai, bi, ci = heappop(h)
print(-v)
if ai + 1 < X and d[(ai + 1, bi, ci)] == False:
heappush(h, (-(A[ai + 1] + B[bi] + C[ci]), ai + 1, bi, ci))
d[(ai + 1, bi, ci)] = True
if bi + 1 < Y and d[(ai, bi + 1, ci)] == False:
heappush(h, (-(A[ai] + B[bi + 1] + C[ci]), ai, bi + 1, ci))
d[(ai, bi + 1, ci)] = True
if ci + 1 < Z and d[(ai, bi, ci + 1)] == False:
heappush(h, (-(A[ai] + B[bi] + C[ci + 1]), ai, bi, ci + 1))
d[(ai, bi, ci + 1)] = True
if __name__ == "__main__":
main()
| false
| 13.043478
|
[
"- ans = []",
"- for ai in range(X):",
"- for bi in range(Y):",
"- if ai * bi > K:",
"- break",
"- for ci in range(Z):",
"- if ai * bi * ci > K:",
"- break",
"- ans.append(A[ai] + B[bi] + C[ci])",
"- ans.sort(reverse=True)",
"- for i in range(K):",
"- print(ans[i])",
"+ from heapq import heappush, heappop",
"+ from collections import defaultdict",
"+",
"+ d = defaultdict(lambda: False)",
"+ h = []",
"+ ai = bi = ci = 0",
"+ heappush(h, (-(A[ai] + B[bi] + C[ci]), ai, bi, ci))",
"+ d[(0, 0, 0)] = True",
"+ for _ in range(K):",
"+ v, ai, bi, ci = heappop(h)",
"+ print(-v)",
"+ if ai + 1 < X and d[(ai + 1, bi, ci)] == False:",
"+ heappush(h, (-(A[ai + 1] + B[bi] + C[ci]), ai + 1, bi, ci))",
"+ d[(ai + 1, bi, ci)] = True",
"+ if bi + 1 < Y and d[(ai, bi + 1, ci)] == False:",
"+ heappush(h, (-(A[ai] + B[bi + 1] + C[ci]), ai, bi + 1, ci))",
"+ d[(ai, bi + 1, ci)] = True",
"+ if ci + 1 < Z and d[(ai, bi, ci + 1)] == False:",
"+ heappush(h, (-(A[ai] + B[bi] + C[ci + 1]), ai, bi, ci + 1))",
"+ d[(ai, bi, ci + 1)] = True"
] | false
| 0.061578
| 0.040478
| 1.521252
|
[
"s851383304",
"s851606142"
] |
u806201407
|
p03776
|
python
|
s209700321
|
s302848696
| 20
| 18
| 3,188
| 3,064
|
Accepted
|
Accepted
| 10
|
from builtins import print
def comb(n, m) :
ans = 1
for i in range(n) :
ans *= i+1
for i in range(m) :
ans //= i+1
for i in range(n-m) :
ans //= i+1
return ans
N, A, B = map(int, input().split())
val = list(reversed(sorted((map(int, input().split())))))
ret = 0
prev = [0, 1]
for i in range(A, B+1) :
cur = [ sum( [ val[j] for j in range(i) ]) , i]
if i > A :
if prev[0] * cur[1] > prev[1] * cur[0] :
break
cntLarge = [ 1 if v > val[A] else 0 for v in val ].count(1)
ret += comb( val.count(val[i-1]) ,i - cntLarge)
prev = cur
print(format(prev[0] / prev[1], '.12f'))
print(ret)
|
import math
def comb(n, m) :
fact = math.factorial
return fact(n) // fact(m) // fact(n-m)
N, A, B = list(map(int, input().split()))
val = list(reversed(sorted(map(int, input().split()))))
ret = 0
prev = [0, 1]
for i in range(A, B + 1):
cur = [sum([val[j] for j in range(i)]), i]
if i > A and prev[0] * cur[1] > prev[1] * cur[0]:
break
ret += comb(val.count(val[i-1]), val[:i].count(val[i-1]))
prev = cur
print((format(prev[0] / prev[1], '.12f')))
print(ret)
| 31
| 20
| 700
| 505
|
from builtins import print
def comb(n, m):
ans = 1
for i in range(n):
ans *= i + 1
for i in range(m):
ans //= i + 1
for i in range(n - m):
ans //= i + 1
return ans
N, A, B = map(int, input().split())
val = list(reversed(sorted((map(int, input().split())))))
ret = 0
prev = [0, 1]
for i in range(A, B + 1):
cur = [sum([val[j] for j in range(i)]), i]
if i > A:
if prev[0] * cur[1] > prev[1] * cur[0]:
break
cntLarge = [1 if v > val[A] else 0 for v in val].count(1)
ret += comb(val.count(val[i - 1]), i - cntLarge)
prev = cur
print(format(prev[0] / prev[1], ".12f"))
print(ret)
|
import math
def comb(n, m):
fact = math.factorial
return fact(n) // fact(m) // fact(n - m)
N, A, B = list(map(int, input().split()))
val = list(reversed(sorted(map(int, input().split()))))
ret = 0
prev = [0, 1]
for i in range(A, B + 1):
cur = [sum([val[j] for j in range(i)]), i]
if i > A and prev[0] * cur[1] > prev[1] * cur[0]:
break
ret += comb(val.count(val[i - 1]), val[:i].count(val[i - 1]))
prev = cur
print((format(prev[0] / prev[1], ".12f")))
print(ret)
| false
| 35.483871
|
[
"-from builtins import print",
"+import math",
"- ans = 1",
"- for i in range(n):",
"- ans *= i + 1",
"- for i in range(m):",
"- ans //= i + 1",
"- for i in range(n - m):",
"- ans //= i + 1",
"- return ans",
"+ fact = math.factorial",
"+ return fact(n) // fact(m) // fact(n - m)",
"-N, A, B = map(int, input().split())",
"-val = list(reversed(sorted((map(int, input().split())))))",
"+N, A, B = list(map(int, input().split()))",
"+val = list(reversed(sorted(map(int, input().split()))))",
"- if i > A:",
"- if prev[0] * cur[1] > prev[1] * cur[0]:",
"- break",
"- cntLarge = [1 if v > val[A] else 0 for v in val].count(1)",
"- ret += comb(val.count(val[i - 1]), i - cntLarge)",
"+ if i > A and prev[0] * cur[1] > prev[1] * cur[0]:",
"+ break",
"+ ret += comb(val.count(val[i - 1]), val[:i].count(val[i - 1]))",
"-print(format(prev[0] / prev[1], \".12f\"))",
"+print((format(prev[0] / prev[1], \".12f\")))"
] | false
| 0.034764
| 0.035392
| 0.98228
|
[
"s209700321",
"s302848696"
] |
u620084012
|
p03761
|
python
|
s850841686
|
s362540663
| 169
| 22
| 38,640
| 3,316
|
Accepted
|
Accepted
| 86.98
|
n = int(eval(input()))
S = "abcdefghijklmnopqrstuvwxyz"
C = [[0 for k in range(n)] for l in range(26)]
for k in range(n):
t = eval(input())
for e in t:
C[ord(e)-97][k] += 1
ans = ""
for k in range(26):
ans += S[k]*min(C[k])
print(ans)
|
from collections import Counter
N = int(eval(input()))
W = [Counter(eval(input())) for k in range(N)]
A = [100000]*26
S = "abcdefghijklmnopqrstuvwxyz"
for e in W:
for s in S:
A[ord(s)-97] = min(A[ord(s)-97],e[s])
ans = ""
for k in range(26):
ans += S[k]*A[k]
print(ans)
| 11
| 13
| 253
| 287
|
n = int(eval(input()))
S = "abcdefghijklmnopqrstuvwxyz"
C = [[0 for k in range(n)] for l in range(26)]
for k in range(n):
t = eval(input())
for e in t:
C[ord(e) - 97][k] += 1
ans = ""
for k in range(26):
ans += S[k] * min(C[k])
print(ans)
|
from collections import Counter
N = int(eval(input()))
W = [Counter(eval(input())) for k in range(N)]
A = [100000] * 26
S = "abcdefghijklmnopqrstuvwxyz"
for e in W:
for s in S:
A[ord(s) - 97] = min(A[ord(s) - 97], e[s])
ans = ""
for k in range(26):
ans += S[k] * A[k]
print(ans)
| false
| 15.384615
|
[
"-n = int(eval(input()))",
"+from collections import Counter",
"+",
"+N = int(eval(input()))",
"+W = [Counter(eval(input())) for k in range(N)]",
"+A = [100000] * 26",
"-C = [[0 for k in range(n)] for l in range(26)]",
"-for k in range(n):",
"- t = eval(input())",
"- for e in t:",
"- C[ord(e) - 97][k] += 1",
"+for e in W:",
"+ for s in S:",
"+ A[ord(s) - 97] = min(A[ord(s) - 97], e[s])",
"- ans += S[k] * min(C[k])",
"+ ans += S[k] * A[k]"
] | false
| 0.056019
| 0.035943
| 1.558541
|
[
"s850841686",
"s362540663"
] |
u197300773
|
p02781
|
python
|
s708413666
|
s552250455
| 446
| 18
| 3,192
| 3,064
|
Accepted
|
Accepted
| 95.96
|
import math
import sys
comb=[0,0,0,1,3,6,10, 15, 21, 28, 36, 45, 55, 66, 78, 91, 105, 120, 136, 153, 171, 190, 210, 231, 253, 276, 300, 325, 351, 378, 406, 435, 465, 496, 528, 561, 595, 630, 666, 703, 741, 780, 820, 861, 903, 946, 990, 1035, 1081, 1128, 1176, 1225, 1275, 1326, 1378, 1431, 1485, 1540, 1596, 1653, 1711, 1770, 1830, 1891, 1953, 2016, 2080, 2145, 2211, 2278, 2346, 2415, 2485, 2556, 2628, 2701, 2775, 2850, 2926, 3003, 3081, 3160, 3240, 3321, 3403, 3486, 3570, 3655, 3741, 3828, 3916, 4005, 4095, 4186, 4278, 4371, 4465, 4560, 4656, 4753, 4851, 4950]
n=int(eval(input()))
k=int(eval(input()))
s=str(n)
L=len(s)
ans=0
if n<k:
ans=0
elif k==1:
for i in range(L):
for a in range(1,10):
if a*(10**i)<=n:
ans+=1
elif k==2:
for i in range(1,L):
for j in range(i):
for a in range(1,10):
for b in range(1,10):
if a*(10**i)+b*(10**j)<=n: ans+=1
elif k==3 and L<4:
for a in range(1,10):
for b in range(1,10):
for c in range(1,10):
if a*100+b*10+c<=n: ans+=1
elif k==3 and L>=4:
ans=sum(comb[:L])*9**3
ans+=comb[L]* 81 * (int(s[0])-1)
m=int(s[1:])
for i in range(1,L-1):
for j in range(i):
for a in range(1,10):
for b in range(1,10):
if a*(10**i)+b*(10**j)<=m: ans+=1
print(ans)
|
import math
import sys
n=int(eval(input()))
k=int(eval(input()))
s=str(n)
l=len(s)
dp0=[[0 for j in range(k+1)] for i in range(l)]
dp1=[[0 for j in range(k+1)] for i in range(l)]
x=int(s[0])
dp0[0][1]=x-1
dp0[0][0]=1
dp1[0][1]=1
for i in range(1,l):
x=int(s[i])
dp0[i][0]=1
for j in range(1,k+1):
dp0[i][j]+=dp0[i-1][j-1]*9+dp0[i-1][j]
if x>0:
dp0[i][j]+=dp1[i-1][j-1]*(x-1)+dp1[i-1][j]
dp1[i][j]=dp1[i-1][j-1]
else:
dp1[i][j]=dp1[i-1][j]
print((dp0[l-1][k]+dp1[l-1][k]))
| 45
| 26
| 1,439
| 558
|
import math
import sys
comb = [
0,
0,
0,
1,
3,
6,
10,
15,
21,
28,
36,
45,
55,
66,
78,
91,
105,
120,
136,
153,
171,
190,
210,
231,
253,
276,
300,
325,
351,
378,
406,
435,
465,
496,
528,
561,
595,
630,
666,
703,
741,
780,
820,
861,
903,
946,
990,
1035,
1081,
1128,
1176,
1225,
1275,
1326,
1378,
1431,
1485,
1540,
1596,
1653,
1711,
1770,
1830,
1891,
1953,
2016,
2080,
2145,
2211,
2278,
2346,
2415,
2485,
2556,
2628,
2701,
2775,
2850,
2926,
3003,
3081,
3160,
3240,
3321,
3403,
3486,
3570,
3655,
3741,
3828,
3916,
4005,
4095,
4186,
4278,
4371,
4465,
4560,
4656,
4753,
4851,
4950,
]
n = int(eval(input()))
k = int(eval(input()))
s = str(n)
L = len(s)
ans = 0
if n < k:
ans = 0
elif k == 1:
for i in range(L):
for a in range(1, 10):
if a * (10**i) <= n:
ans += 1
elif k == 2:
for i in range(1, L):
for j in range(i):
for a in range(1, 10):
for b in range(1, 10):
if a * (10**i) + b * (10**j) <= n:
ans += 1
elif k == 3 and L < 4:
for a in range(1, 10):
for b in range(1, 10):
for c in range(1, 10):
if a * 100 + b * 10 + c <= n:
ans += 1
elif k == 3 and L >= 4:
ans = sum(comb[:L]) * 9**3
ans += comb[L] * 81 * (int(s[0]) - 1)
m = int(s[1:])
for i in range(1, L - 1):
for j in range(i):
for a in range(1, 10):
for b in range(1, 10):
if a * (10**i) + b * (10**j) <= m:
ans += 1
print(ans)
|
import math
import sys
n = int(eval(input()))
k = int(eval(input()))
s = str(n)
l = len(s)
dp0 = [[0 for j in range(k + 1)] for i in range(l)]
dp1 = [[0 for j in range(k + 1)] for i in range(l)]
x = int(s[0])
dp0[0][1] = x - 1
dp0[0][0] = 1
dp1[0][1] = 1
for i in range(1, l):
x = int(s[i])
dp0[i][0] = 1
for j in range(1, k + 1):
dp0[i][j] += dp0[i - 1][j - 1] * 9 + dp0[i - 1][j]
if x > 0:
dp0[i][j] += dp1[i - 1][j - 1] * (x - 1) + dp1[i - 1][j]
dp1[i][j] = dp1[i - 1][j - 1]
else:
dp1[i][j] = dp1[i - 1][j]
print((dp0[l - 1][k] + dp1[l - 1][k]))
| false
| 42.222222
|
[
"-comb = [",
"- 0,",
"- 0,",
"- 0,",
"- 1,",
"- 3,",
"- 6,",
"- 10,",
"- 15,",
"- 21,",
"- 28,",
"- 36,",
"- 45,",
"- 55,",
"- 66,",
"- 78,",
"- 91,",
"- 105,",
"- 120,",
"- 136,",
"- 153,",
"- 171,",
"- 190,",
"- 210,",
"- 231,",
"- 253,",
"- 276,",
"- 300,",
"- 325,",
"- 351,",
"- 378,",
"- 406,",
"- 435,",
"- 465,",
"- 496,",
"- 528,",
"- 561,",
"- 595,",
"- 630,",
"- 666,",
"- 703,",
"- 741,",
"- 780,",
"- 820,",
"- 861,",
"- 903,",
"- 946,",
"- 990,",
"- 1035,",
"- 1081,",
"- 1128,",
"- 1176,",
"- 1225,",
"- 1275,",
"- 1326,",
"- 1378,",
"- 1431,",
"- 1485,",
"- 1540,",
"- 1596,",
"- 1653,",
"- 1711,",
"- 1770,",
"- 1830,",
"- 1891,",
"- 1953,",
"- 2016,",
"- 2080,",
"- 2145,",
"- 2211,",
"- 2278,",
"- 2346,",
"- 2415,",
"- 2485,",
"- 2556,",
"- 2628,",
"- 2701,",
"- 2775,",
"- 2850,",
"- 2926,",
"- 3003,",
"- 3081,",
"- 3160,",
"- 3240,",
"- 3321,",
"- 3403,",
"- 3486,",
"- 3570,",
"- 3655,",
"- 3741,",
"- 3828,",
"- 3916,",
"- 4005,",
"- 4095,",
"- 4186,",
"- 4278,",
"- 4371,",
"- 4465,",
"- 4560,",
"- 4656,",
"- 4753,",
"- 4851,",
"- 4950,",
"-]",
"-L = len(s)",
"-ans = 0",
"-if n < k:",
"- ans = 0",
"-elif k == 1:",
"- for i in range(L):",
"- for a in range(1, 10):",
"- if a * (10**i) <= n:",
"- ans += 1",
"-elif k == 2:",
"- for i in range(1, L):",
"- for j in range(i):",
"- for a in range(1, 10):",
"- for b in range(1, 10):",
"- if a * (10**i) + b * (10**j) <= n:",
"- ans += 1",
"-elif k == 3 and L < 4:",
"- for a in range(1, 10):",
"- for b in range(1, 10):",
"- for c in range(1, 10):",
"- if a * 100 + b * 10 + c <= n:",
"- ans += 1",
"-elif k == 3 and L >= 4:",
"- ans = sum(comb[:L]) * 9**3",
"- ans += comb[L] * 81 * (int(s[0]) - 1)",
"- m = int(s[1:])",
"- for i in range(1, L - 1):",
"- for j in range(i):",
"- for a in range(1, 10):",
"- for b in range(1, 10):",
"- if a * (10**i) + b * (10**j) <= m:",
"- ans += 1",
"-print(ans)",
"+l = len(s)",
"+dp0 = [[0 for j in range(k + 1)] for i in range(l)]",
"+dp1 = [[0 for j in range(k + 1)] for i in range(l)]",
"+x = int(s[0])",
"+dp0[0][1] = x - 1",
"+dp0[0][0] = 1",
"+dp1[0][1] = 1",
"+for i in range(1, l):",
"+ x = int(s[i])",
"+ dp0[i][0] = 1",
"+ for j in range(1, k + 1):",
"+ dp0[i][j] += dp0[i - 1][j - 1] * 9 + dp0[i - 1][j]",
"+ if x > 0:",
"+ dp0[i][j] += dp1[i - 1][j - 1] * (x - 1) + dp1[i - 1][j]",
"+ dp1[i][j] = dp1[i - 1][j - 1]",
"+ else:",
"+ dp1[i][j] = dp1[i - 1][j]",
"+print((dp0[l - 1][k] + dp1[l - 1][k]))"
] | false
| 0.080976
| 0.03547
| 2.282957
|
[
"s708413666",
"s552250455"
] |
u080364835
|
p02971
|
python
|
s326388092
|
s488411680
| 389
| 356
| 27,376
| 19,064
|
Accepted
|
Accepted
| 8.48
|
from collections import Counter
n = int(eval(input()))
al = [int(eval(input())) for _ in range(n)]
al_s = sorted(al, reverse=True)
c = Counter(al_s)
ck = list(c.keys())
cv = list(c.values())
for a in al:
if a == ck[0]:
if cv[0] == 1:
print((ck[1]))
else:
print((ck[0]))
else:
print((ck[0]))
|
n = int(eval(input()))
al = list(int(eval(input())) for _ in range(n))
al_s = sorted(al)
fir = al_s[-1]
sec = al_s[-2]
for a in al:
if a == fir:
print(sec)
else:
print(fir)
| 19
| 12
| 351
| 198
|
from collections import Counter
n = int(eval(input()))
al = [int(eval(input())) for _ in range(n)]
al_s = sorted(al, reverse=True)
c = Counter(al_s)
ck = list(c.keys())
cv = list(c.values())
for a in al:
if a == ck[0]:
if cv[0] == 1:
print((ck[1]))
else:
print((ck[0]))
else:
print((ck[0]))
|
n = int(eval(input()))
al = list(int(eval(input())) for _ in range(n))
al_s = sorted(al)
fir = al_s[-1]
sec = al_s[-2]
for a in al:
if a == fir:
print(sec)
else:
print(fir)
| false
| 36.842105
|
[
"-from collections import Counter",
"-",
"-al = [int(eval(input())) for _ in range(n)]",
"-al_s = sorted(al, reverse=True)",
"-c = Counter(al_s)",
"-ck = list(c.keys())",
"-cv = list(c.values())",
"+al = list(int(eval(input())) for _ in range(n))",
"+al_s = sorted(al)",
"+fir = al_s[-1]",
"+sec = al_s[-2]",
"- if a == ck[0]:",
"- if cv[0] == 1:",
"- print((ck[1]))",
"- else:",
"- print((ck[0]))",
"+ if a == fir:",
"+ print(sec)",
"- print((ck[0]))",
"+ print(fir)"
] | false
| 0.036074
| 0.035218
| 1.024302
|
[
"s326388092",
"s488411680"
] |
u558242240
|
p02744
|
python
|
s061160598
|
s997365817
| 581
| 529
| 28,968
| 4,404
|
Accepted
|
Accepted
| 8.95
|
n = int(eval(input()))
ans = []
def dfs(x):
if len(x) == n:
ans.append(x)
return
for i in range(max(x)+1):
y = x.copy()
y.append(i+1)
dfs(y)
dfs([1])
#print(ans)
for ai in ans:
print((''.join([chr(ord('a') + x - 1) for x in ai])))
#r = ['a','b','c','d','e','f','g','h','i','j']
#for ai in ans:
# print(''.join(map(lambda x: str(r[x-1]), ai)))
|
n = int(eval(input()))
ans = []
def dfs(x):
if len(x) == n:
print((''.join([chr(ord('a') + i - 1) for i in x])))
return
for i in range(max(x)+1):
y = x.copy()
y.append(i+1)
dfs(y)
dfs([1])
| 22
| 12
| 421
| 246
|
n = int(eval(input()))
ans = []
def dfs(x):
if len(x) == n:
ans.append(x)
return
for i in range(max(x) + 1):
y = x.copy()
y.append(i + 1)
dfs(y)
dfs([1])
# print(ans)
for ai in ans:
print(("".join([chr(ord("a") + x - 1) for x in ai])))
# r = ['a','b','c','d','e','f','g','h','i','j']
# for ai in ans:
# print(''.join(map(lambda x: str(r[x-1]), ai)))
|
n = int(eval(input()))
ans = []
def dfs(x):
if len(x) == n:
print(("".join([chr(ord("a") + i - 1) for i in x])))
return
for i in range(max(x) + 1):
y = x.copy()
y.append(i + 1)
dfs(y)
dfs([1])
| false
| 45.454545
|
[
"- ans.append(x)",
"+ print((\"\".join([chr(ord(\"a\") + i - 1) for i in x])))",
"-# print(ans)",
"-for ai in ans:",
"- print((\"\".join([chr(ord(\"a\") + x - 1) for x in ai])))",
"-# r = ['a','b','c','d','e','f','g','h','i','j']",
"-# for ai in ans:",
"-# print(''.join(map(lambda x: str(r[x-1]), ai)))"
] | false
| 0.03787
| 0.038227
| 0.990648
|
[
"s061160598",
"s997365817"
] |
u281303342
|
p03458
|
python
|
s004237403
|
s199069234
| 1,847
| 1,284
| 101,884
| 101,888
|
Accepted
|
Accepted
| 30.48
|
import numpy as np
import sys
def sum2d(i1,j1,i2,j2):
A[i1][j1] += 1
A[i1][j2] -= 1
A[i2][j1] -= 1
A[i2][j2] += 1
N,K = list(map(int,input().split()))
XYC = [list(input().split()) for _ in range(N)]
A = [[0 for _ in range(K*2+1)] for _ in range(K*2+1)]
for x,y,c in XYC:
i = (int(x) if c=="W" else int(x)+K) % (K*2)
j = int(y) % (K*2)
i0 = i%K
j0 = j%K
if (i<K and j<K) or (i>=K and j>=K):
sum2d(0,0,i0,j0) # 左上
sum2d(i0+K,0,K*2,j0) # 右上
sum2d(i0,j0,i0+K,j0+K) # 真ん中
sum2d(0,j0+K,i0,K*2) # 左下
sum2d(i0+K,j0+K,K*2,K*2) # 右下
else:
sum2d(i0,0,i0+K,j0) # 上
sum2d(0,j0,i0,j0+K) # 左
sum2d(i0+K,j0,K*2,j0+K) # 右
sum2d(i0,j0+K,i0+K,K*2) # 下
# 2次元累積和
AA = np.array(A)
for i in range(K*2):
AA[i+1, :] += AA[i, :]
for j in range(K*2):
AA[:, j+1] += AA[:, j]
print((AA.max()))
|
# python 3.4.3
import sys
input = sys.stdin.readline
import numpy as np
# -------------------------------------------------------------
# function
# -------------------------------------------------------------
def sum2d(i1,j1,i2,j2):
A[i1][j1] += 1
A[i1][j2] -= 1
A[i2][j1] -= 1
A[i2][j2] += 1
# -------------------------------------------------------------
# main
# -------------------------------------------------------------
N,K = list(map(int,input().split()))
XYC = [list(input().split()) for _ in range(N)]
A = [[0 for _ in range(K*2+1)] for _ in range(K*2+1)]
for x,y,c in XYC:
# 白はそのまま, 黒はx軸方向にKずらして白として扱う
i = (int(x) if c=="W" else int(x)+K) % (K*2)
j = int(y) % (K*2)
i0 = i%K
j0 = j%K
# 分割区画の左下が白の場合 (白は5箇所)
# a * b
# * c *
# d * e
if (i<K and j<K) or (i>=K and j>=K):
sum2d(0,0,i0,j0) # (a)左上
sum2d(i0+K,0,K*2,j0) # (b)右上
sum2d(i0,j0,i0+K,j0+K) # (c)真ん中
sum2d(0,j0+K,i0,K*2) # (d)左下
sum2d(i0+K,j0+K,K*2,K*2) # (e)右下
# 分割区画の左下が黒の場合 (白は4箇所)
# * a *
# b * c
# * d *
else:
sum2d(i0,0,i0+K,j0) # (a)上
sum2d(0,j0,i0,j0+K) # (b)左
sum2d(i0+K,j0,K*2,j0+K) # (c)右
sum2d(i0,j0+K,i0+K,K*2) # (d)下
# 2次元累積和
AA = np.array(A)
for i in range(K*2):
AA[i+1, :] += AA[i, :]
for j in range(K*2):
AA[:, j+1] += AA[:, j]
print((AA.max()))
| 41
| 60
| 925
| 1,462
|
import numpy as np
import sys
def sum2d(i1, j1, i2, j2):
A[i1][j1] += 1
A[i1][j2] -= 1
A[i2][j1] -= 1
A[i2][j2] += 1
N, K = list(map(int, input().split()))
XYC = [list(input().split()) for _ in range(N)]
A = [[0 for _ in range(K * 2 + 1)] for _ in range(K * 2 + 1)]
for x, y, c in XYC:
i = (int(x) if c == "W" else int(x) + K) % (K * 2)
j = int(y) % (K * 2)
i0 = i % K
j0 = j % K
if (i < K and j < K) or (i >= K and j >= K):
sum2d(0, 0, i0, j0) # 左上
sum2d(i0 + K, 0, K * 2, j0) # 右上
sum2d(i0, j0, i0 + K, j0 + K) # 真ん中
sum2d(0, j0 + K, i0, K * 2) # 左下
sum2d(i0 + K, j0 + K, K * 2, K * 2) # 右下
else:
sum2d(i0, 0, i0 + K, j0) # 上
sum2d(0, j0, i0, j0 + K) # 左
sum2d(i0 + K, j0, K * 2, j0 + K) # 右
sum2d(i0, j0 + K, i0 + K, K * 2) # 下
# 2次元累積和
AA = np.array(A)
for i in range(K * 2):
AA[i + 1, :] += AA[i, :]
for j in range(K * 2):
AA[:, j + 1] += AA[:, j]
print((AA.max()))
|
# python 3.4.3
import sys
input = sys.stdin.readline
import numpy as np
# -------------------------------------------------------------
# function
# -------------------------------------------------------------
def sum2d(i1, j1, i2, j2):
A[i1][j1] += 1
A[i1][j2] -= 1
A[i2][j1] -= 1
A[i2][j2] += 1
# -------------------------------------------------------------
# main
# -------------------------------------------------------------
N, K = list(map(int, input().split()))
XYC = [list(input().split()) for _ in range(N)]
A = [[0 for _ in range(K * 2 + 1)] for _ in range(K * 2 + 1)]
for x, y, c in XYC:
# 白はそのまま, 黒はx軸方向にKずらして白として扱う
i = (int(x) if c == "W" else int(x) + K) % (K * 2)
j = int(y) % (K * 2)
i0 = i % K
j0 = j % K
# 分割区画の左下が白の場合 (白は5箇所)
# a * b
# * c *
# d * e
if (i < K and j < K) or (i >= K and j >= K):
sum2d(0, 0, i0, j0) # (a)左上
sum2d(i0 + K, 0, K * 2, j0) # (b)右上
sum2d(i0, j0, i0 + K, j0 + K) # (c)真ん中
sum2d(0, j0 + K, i0, K * 2) # (d)左下
sum2d(i0 + K, j0 + K, K * 2, K * 2) # (e)右下
# 分割区画の左下が黒の場合 (白は4箇所)
# * a *
# b * c
# * d *
else:
sum2d(i0, 0, i0 + K, j0) # (a)上
sum2d(0, j0, i0, j0 + K) # (b)左
sum2d(i0 + K, j0, K * 2, j0 + K) # (c)右
sum2d(i0, j0 + K, i0 + K, K * 2) # (d)下
# 2次元累積和
AA = np.array(A)
for i in range(K * 2):
AA[i + 1, :] += AA[i, :]
for j in range(K * 2):
AA[:, j + 1] += AA[:, j]
print((AA.max()))
| false
| 31.666667
|
[
"-import numpy as np",
"+# python 3.4.3",
"+input = sys.stdin.readline",
"+import numpy as np",
"+# function",
"+# main",
"+ # 白はそのまま, 黒はx軸方向にKずらして白として扱う",
"+ # 分割区画の左下が白の場合 (白は5箇所)",
"+ # a * b",
"+ # * c *",
"+ # d * e",
"- sum2d(0, 0, i0, j0) # 左上",
"- sum2d(i0 + K, 0, K * 2, j0) # 右上",
"- sum2d(i0, j0, i0 + K, j0 + K) # 真ん中",
"- sum2d(0, j0 + K, i0, K * 2) # 左下",
"- sum2d(i0 + K, j0 + K, K * 2, K * 2) # 右下",
"+ sum2d(0, 0, i0, j0) # (a)左上",
"+ sum2d(i0 + K, 0, K * 2, j0) # (b)右上",
"+ sum2d(i0, j0, i0 + K, j0 + K) # (c)真ん中",
"+ sum2d(0, j0 + K, i0, K * 2) # (d)左下",
"+ sum2d(i0 + K, j0 + K, K * 2, K * 2) # (e)右下",
"+ # 分割区画の左下が黒の場合 (白は4箇所)",
"+ # * a *",
"+ # b * c",
"+ # * d *",
"- sum2d(i0, 0, i0 + K, j0) # 上",
"- sum2d(0, j0, i0, j0 + K) # 左",
"- sum2d(i0 + K, j0, K * 2, j0 + K) # 右",
"- sum2d(i0, j0 + K, i0 + K, K * 2) # 下",
"+ sum2d(i0, 0, i0 + K, j0) # (a)上",
"+ sum2d(0, j0, i0, j0 + K) # (b)左",
"+ sum2d(i0 + K, j0, K * 2, j0 + K) # (c)右",
"+ sum2d(i0, j0 + K, i0 + K, K * 2) # (d)下"
] | false
| 0.311574
| 0.561712
| 0.554686
|
[
"s004237403",
"s199069234"
] |
u525065967
|
p02695
|
python
|
s946161450
|
s770632039
| 1,046
| 698
| 9,168
| 9,172
|
Accepted
|
Accepted
| 33.27
|
n,m,q = list(map(int,input().split()))
abcd = [[*list(map(int,input().split()))] for _ in range(q)]
from itertools import *
ans = 0
for A in combinations_with_replacement(list(range(1, m+1)), n): # nHr
now = 0
for a,b,c,d in abcd:
if A[b-1] - A[a-1] == c: now += d
ans = max(ans, now)
print(ans)
|
n,m,q = list(map(int,input().split()))
abcd = [[*list(map(int,input().split()))] for _ in range(q)]
from itertools import *
ans = 0
for A in combinations_with_replacement(list(range(1, m+1)), n): # nHr
now = sum(d if A[b-1] - A[a-1] == c else 0 for a,b,c,d in abcd)
ans = max(ans, now)
print(ans)
| 10
| 8
| 307
| 294
|
n, m, q = list(map(int, input().split()))
abcd = [[*list(map(int, input().split()))] for _ in range(q)]
from itertools import *
ans = 0
for A in combinations_with_replacement(list(range(1, m + 1)), n): # nHr
now = 0
for a, b, c, d in abcd:
if A[b - 1] - A[a - 1] == c:
now += d
ans = max(ans, now)
print(ans)
|
n, m, q = list(map(int, input().split()))
abcd = [[*list(map(int, input().split()))] for _ in range(q)]
from itertools import *
ans = 0
for A in combinations_with_replacement(list(range(1, m + 1)), n): # nHr
now = sum(d if A[b - 1] - A[a - 1] == c else 0 for a, b, c, d in abcd)
ans = max(ans, now)
print(ans)
| false
| 20
|
[
"- now = 0",
"- for a, b, c, d in abcd:",
"- if A[b - 1] - A[a - 1] == c:",
"- now += d",
"+ now = sum(d if A[b - 1] - A[a - 1] == c else 0 for a, b, c, d in abcd)"
] | false
| 0.053213
| 0.05771
| 0.922074
|
[
"s946161450",
"s770632039"
] |
u084357428
|
p03308
|
python
|
s499939100
|
s064699784
| 19
| 17
| 3,060
| 2,940
|
Accepted
|
Accepted
| 10.53
|
n=int(eval(input()))
a=[int(_) for _ in input().split()]
ans = 0
for i in range(1,n):
for j in range(i):
ans = max(ans,abs(a[i]-a[j]))
print(ans)
|
n=int(eval(input()))
a=list(map(int,input().split()))
print((max(a)-min(a)))
| 7
| 3
| 157
| 70
|
n = int(eval(input()))
a = [int(_) for _ in input().split()]
ans = 0
for i in range(1, n):
for j in range(i):
ans = max(ans, abs(a[i] - a[j]))
print(ans)
|
n = int(eval(input()))
a = list(map(int, input().split()))
print((max(a) - min(a)))
| false
| 57.142857
|
[
"-a = [int(_) for _ in input().split()]",
"-ans = 0",
"-for i in range(1, n):",
"- for j in range(i):",
"- ans = max(ans, abs(a[i] - a[j]))",
"-print(ans)",
"+a = list(map(int, input().split()))",
"+print((max(a) - min(a)))"
] | false
| 0.038917
| 0.04974
| 0.782412
|
[
"s499939100",
"s064699784"
] |
u325206354
|
p03796
|
python
|
s729287294
|
s832482671
| 44
| 35
| 2,940
| 2,940
|
Accepted
|
Accepted
| 20.45
|
X=10**9+7
def A(c,d):
return c*d%X
a=int(eval(input()))
x=1
for i in range(1,a+1):
x = A(x,i)
print(x)
|
X=10**9+7
a=int(eval(input()))
x=1
for i in range(1,a+1):
x = x*i%X
print(x)
| 11
| 8
| 118
| 84
|
X = 10**9 + 7
def A(c, d):
return c * d % X
a = int(eval(input()))
x = 1
for i in range(1, a + 1):
x = A(x, i)
print(x)
|
X = 10**9 + 7
a = int(eval(input()))
x = 1
for i in range(1, a + 1):
x = x * i % X
print(x)
| false
| 27.272727
|
[
"-",
"-",
"-def A(c, d):",
"- return c * d % X",
"-",
"-",
"- x = A(x, i)",
"+ x = x * i % X"
] | false
| 0.047425
| 0.087627
| 0.541216
|
[
"s729287294",
"s832482671"
] |
u414920281
|
p03805
|
python
|
s924610813
|
s501515767
| 35
| 24
| 3,064
| 3,064
|
Accepted
|
Accepted
| 31.43
|
import itertools
n,m=list(map(int,input().split()))
path=[[False]*n for i in range(n)]
for i in range(m):
a,b=list(map(int,input().split()))
a-=1
b-=1
path[a][b]=True
path[b][a]=True
ans=0;
for i in itertools.permutations(list(range(n)),n):
if i[0]==0:
for j in range(n):
if j==n-1:
ans+=1
break
if not path[i[j]][i[j+1]]:
break
print(ans)
|
def dfs(a,count,seen):
nseen=seen[:]
ans=0
nseen[a] = 1;
if count==n-1:
return 1
else:
for i in g[a]:
if not seen[i]:
ans+=dfs(i,count+1,nseen)
return ans
n,m=list(map(int,input().split()))
g=[[]*n for i in range(n)]
for i in range(m):
a,b=list(map(int,input().split()))
a-=1
b-=1
g[a].append(b)
g[b].append(a)
seen=[0]*n
print((dfs(0,0,seen)))
| 20
| 21
| 445
| 443
|
import itertools
n, m = list(map(int, input().split()))
path = [[False] * n for i in range(n)]
for i in range(m):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
path[a][b] = True
path[b][a] = True
ans = 0
for i in itertools.permutations(list(range(n)), n):
if i[0] == 0:
for j in range(n):
if j == n - 1:
ans += 1
break
if not path[i[j]][i[j + 1]]:
break
print(ans)
|
def dfs(a, count, seen):
nseen = seen[:]
ans = 0
nseen[a] = 1
if count == n - 1:
return 1
else:
for i in g[a]:
if not seen[i]:
ans += dfs(i, count + 1, nseen)
return ans
n, m = list(map(int, input().split()))
g = [[] * n for i in range(n)]
for i in range(m):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
g[a].append(b)
g[b].append(a)
seen = [0] * n
print((dfs(0, 0, seen)))
| false
| 4.761905
|
[
"-import itertools",
"+def dfs(a, count, seen):",
"+ nseen = seen[:]",
"+ ans = 0",
"+ nseen[a] = 1",
"+ if count == n - 1:",
"+ return 1",
"+ else:",
"+ for i in g[a]:",
"+ if not seen[i]:",
"+ ans += dfs(i, count + 1, nseen)",
"+ return ans",
"+",
"-path = [[False] * n for i in range(n)]",
"+g = [[] * n for i in range(n)]",
"- path[a][b] = True",
"- path[b][a] = True",
"-ans = 0",
"-for i in itertools.permutations(list(range(n)), n):",
"- if i[0] == 0:",
"- for j in range(n):",
"- if j == n - 1:",
"- ans += 1",
"- break",
"- if not path[i[j]][i[j + 1]]:",
"- break",
"-print(ans)",
"+ g[a].append(b)",
"+ g[b].append(a)",
"+seen = [0] * n",
"+print((dfs(0, 0, seen)))"
] | false
| 0.059167
| 0.046273
| 1.278641
|
[
"s924610813",
"s501515767"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.