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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
u214304095 | p02983 | python | s218198398 | s506965799 | 839 | 60 | 2,940 | 2,940 | Accepted | Accepted | 92.85 | l, r = list(map(int, input().split()))
ans = 10000
for i in range(l, min(r, l + 2030)):
for j in range(i + 1, min(r + 1, l + 2030)):
ans = min(ans, (i * j) % 2019)
print(ans)
| l, r = list(map(int, input().split()))
ans = 10000
for i in range(l, min(r, l + 2030)):
for j in range(i + 1, min(r + 1, l + 2030)):
ans = min(ans, (i * j) % 2019)
if ans == 0:
print(ans)
exit()
print(ans)
| 6 | 9 | 187 | 253 | l, r = list(map(int, input().split()))
ans = 10000
for i in range(l, min(r, l + 2030)):
for j in range(i + 1, min(r + 1, l + 2030)):
ans = min(ans, (i * j) % 2019)
print(ans)
| l, r = list(map(int, input().split()))
ans = 10000
for i in range(l, min(r, l + 2030)):
for j in range(i + 1, min(r + 1, l + 2030)):
ans = min(ans, (i * j) % 2019)
if ans == 0:
print(ans)
exit()
print(ans)
| false | 33.333333 | [
"+ if ans == 0:",
"+ print(ans)",
"+ exit()"
]
| false | 0.073297 | 0.036605 | 2.002368 | [
"s218198398",
"s506965799"
]
|
u422104747 | p03286 | python | s613293705 | s961823421 | 231 | 195 | 57,968 | 38,512 | Accepted | Accepted | 15.58 | import bisect
def put(a,b): #結果の表示
l=max(len(a),len(b)) #aとbの長さが違うときに壊れるので以下で十分な長さの0を結合しておく
a="0"*l+a
b="0"*l+b
s=""
for i in range(-1,-l-1,-1): #長さの偶奇を考えたくないので逆順に生成してあとで反転
s+=a[i]+b[i]
s=s[-1::-1] #反転
ind=s.find("1")
print((s[ind:])) #頭にたくさんついている0を除いて表示
def quad(i): #数値を4進数表記の文字列に直す。16→"100"など。
s=""
while i>0:
s+=str(i%4)
i//=4
return s[-1::-1]
l=[0,1]
for i in range(1,18): #候補の生成。最長で18ビット。
l+=[4**i+j for j in l]
n=int(eval(input()))
if n==0: #n==0は出力が空文字になってしまうので別に扱う
print("0")
else:
for i in range(len(l)):
ind=bisect.bisect_left(l,(l[i]-n)//2)
if l[i]-2*l[ind]==n:
put(quad(l[i]),quad(l[ind]))
break | def solve(n):
ret=""
i=0
while True:
if i%2==1 and n%2==1: #奇数ビットが1のとき
n+=2
ret+=str(n%2)
n//=2
if n==0:
break
i+=1
return ret[-1::-1] #逆順に結合されているので反転
n=int(eval(input()))
if n==0:
print((0))
elif n<0: #負数は左ビットシフトして一文字落とす
print((solve(n*(-2))[:-1]))
else:
print((solve(n)))
| 32 | 20 | 754 | 374 | import bisect
def put(a, b): # 結果の表示
l = max(len(a), len(b)) # aとbの長さが違うときに壊れるので以下で十分な長さの0を結合しておく
a = "0" * l + a
b = "0" * l + b
s = ""
for i in range(-1, -l - 1, -1): # 長さの偶奇を考えたくないので逆順に生成してあとで反転
s += a[i] + b[i]
s = s[-1::-1] # 反転
ind = s.find("1")
print((s[ind:])) # 頭にたくさんついている0を除いて表示
def quad(i): # 数値を4進数表記の文字列に直す。16→"100"など。
s = ""
while i > 0:
s += str(i % 4)
i //= 4
return s[-1::-1]
l = [0, 1]
for i in range(1, 18): # 候補の生成。最長で18ビット。
l += [4**i + j for j in l]
n = int(eval(input()))
if n == 0: # n==0は出力が空文字になってしまうので別に扱う
print("0")
else:
for i in range(len(l)):
ind = bisect.bisect_left(l, (l[i] - n) // 2)
if l[i] - 2 * l[ind] == n:
put(quad(l[i]), quad(l[ind]))
break
| def solve(n):
ret = ""
i = 0
while True:
if i % 2 == 1 and n % 2 == 1: # 奇数ビットが1のとき
n += 2
ret += str(n % 2)
n //= 2
if n == 0:
break
i += 1
return ret[-1::-1] # 逆順に結合されているので反転
n = int(eval(input()))
if n == 0:
print((0))
elif n < 0: # 負数は左ビットシフトして一文字落とす
print((solve(n * (-2))[:-1]))
else:
print((solve(n)))
| false | 37.5 | [
"-import bisect",
"+def solve(n):",
"+ ret = \"\"",
"+ i = 0",
"+ while True:",
"+ if i % 2 == 1 and n % 2 == 1: # 奇数ビットが1のとき",
"+ n += 2",
"+ ret += str(n % 2)",
"+ n //= 2",
"+ if n == 0:",
"+ break",
"+ i += 1",
"+ return ret[-1::-1] # 逆順に結合されているので反転",
"-def put(a, b): # 結果の表示",
"- l = max(len(a), len(b)) # aとbの長さが違うときに壊れるので以下で十分な長さの0を結合しておく",
"- a = \"0\" * l + a",
"- b = \"0\" * l + b",
"- s = \"\"",
"- for i in range(-1, -l - 1, -1): # 長さの偶奇を考えたくないので逆順に生成してあとで反転",
"- s += a[i] + b[i]",
"- s = s[-1::-1] # 反転",
"- ind = s.find(\"1\")",
"- print((s[ind:])) # 頭にたくさんついている0を除いて表示",
"-",
"-",
"-def quad(i): # 数値を4進数表記の文字列に直す。16→\"100\"など。",
"- s = \"\"",
"- while i > 0:",
"- s += str(i % 4)",
"- i //= 4",
"- return s[-1::-1]",
"-",
"-",
"-l = [0, 1]",
"-for i in range(1, 18): # 候補の生成。最長で18ビット。",
"- l += [4**i + j for j in l]",
"-if n == 0: # n==0は出力が空文字になってしまうので別に扱う",
"- print(\"0\")",
"+if n == 0:",
"+ print((0))",
"+elif n < 0: # 負数は左ビットシフトして一文字落とす",
"+ print((solve(n * (-2))[:-1]))",
"- for i in range(len(l)):",
"- ind = bisect.bisect_left(l, (l[i] - n) // 2)",
"- if l[i] - 2 * l[ind] == n:",
"- put(quad(l[i]), quad(l[ind]))",
"- break",
"+ print((solve(n)))"
]
| false | 0.199829 | 0.037219 | 5.369053 | [
"s613293705",
"s961823421"
]
|
u494927057 | p03836 | python | s529053583 | s590796801 | 19 | 17 | 3,064 | 3,060 | Accepted | Accepted | 10.53 | sx, sy, tx, ty = list(map(int, input().split()))
def get_route(start_x, start_y, end_x, end_y):
route = ''
d_y = end_y - start_y
dir = ''
if d_y < 0:
dir = 'D'
else:
dir = 'U'
for i in range(abs(d_y)):
route += dir
d_x = end_x - start_x
dir = ''
if d_x < 0:
dir = 'L'
else:
dir = 'R'
for i in range(abs(d_x)):
route += dir
return route
ans = get_route(sx, sy, tx, ty)
ans += get_route(tx, ty, sx, sy)
ans += 'LU' + get_route(sx, sy, tx, ty) + 'RD'
ans += 'RD' + get_route(tx, ty, sx, sy) + 'LU'
print(ans)
| sx, sy, tx, ty = list(map(int, input().split()))
dy = ty - sy
dx = tx - sx
print(('U' * dy + 'R' * dx +
'D' * dy + 'L' * dx +
'LU' + 'U' * dy + 'R' * dx + 'RD' +
'RD' + 'D' * dy + 'L' * dx + 'LU')) | 32 | 9 | 634 | 217 | sx, sy, tx, ty = list(map(int, input().split()))
def get_route(start_x, start_y, end_x, end_y):
route = ""
d_y = end_y - start_y
dir = ""
if d_y < 0:
dir = "D"
else:
dir = "U"
for i in range(abs(d_y)):
route += dir
d_x = end_x - start_x
dir = ""
if d_x < 0:
dir = "L"
else:
dir = "R"
for i in range(abs(d_x)):
route += dir
return route
ans = get_route(sx, sy, tx, ty)
ans += get_route(tx, ty, sx, sy)
ans += "LU" + get_route(sx, sy, tx, ty) + "RD"
ans += "RD" + get_route(tx, ty, sx, sy) + "LU"
print(ans)
| sx, sy, tx, ty = list(map(int, input().split()))
dy = ty - sy
dx = tx - sx
print(
(
"U" * dy
+ "R" * dx
+ "D" * dy
+ "L" * dx
+ "LU"
+ "U" * dy
+ "R" * dx
+ "RD"
+ "RD"
+ "D" * dy
+ "L" * dx
+ "LU"
)
)
| false | 71.875 | [
"-",
"-",
"-def get_route(start_x, start_y, end_x, end_y):",
"- route = \"\"",
"- d_y = end_y - start_y",
"- dir = \"\"",
"- if d_y < 0:",
"- dir = \"D\"",
"- else:",
"- dir = \"U\"",
"- for i in range(abs(d_y)):",
"- route += dir",
"- d_x = end_x - start_x",
"- dir = \"\"",
"- if d_x < 0:",
"- dir = \"L\"",
"- else:",
"- dir = \"R\"",
"- for i in range(abs(d_x)):",
"- route += dir",
"- return route",
"-",
"-",
"-ans = get_route(sx, sy, tx, ty)",
"-ans += get_route(tx, ty, sx, sy)",
"-ans += \"LU\" + get_route(sx, sy, tx, ty) + \"RD\"",
"-ans += \"RD\" + get_route(tx, ty, sx, sy) + \"LU\"",
"-print(ans)",
"+dy = ty - sy",
"+dx = tx - sx",
"+print(",
"+ (",
"+ \"U\" * dy",
"+ + \"R\" * dx",
"+ + \"D\" * dy",
"+ + \"L\" * dx",
"+ + \"LU\"",
"+ + \"U\" * dy",
"+ + \"R\" * dx",
"+ + \"RD\"",
"+ + \"RD\"",
"+ + \"D\" * dy",
"+ + \"L\" * dx",
"+ + \"LU\"",
"+ )",
"+)"
]
| false | 0.143074 | 0.138275 | 1.034704 | [
"s529053583",
"s590796801"
]
|
u697559326 | p03166 | python | s548526948 | s731781393 | 633 | 517 | 50,300 | 49,536 | Accepted | Accepted | 18.33 | from collections import defaultdict, deque
v, n = list(map(int, input().split()))
es = [[int(x) for x in input().split()] for _ in range(n)]
outs = defaultdict(list)
ins = defaultdict(int)
#print(ins)
for v1, v2 in es:
outs[v1].append(v2)
ins[v2] += 1
#print(ins)
#print("be",ins)
q = deque(v1 for v1 in range(v+1) if ins[v1] == 0)
#print("af",ins)
res = []
#print(outs)
#print(ins)
while q:
#print(q)
v1 = q.popleft()
res.append(v1)
for v2 in outs[v1]:
#print("-->",v2)
ins[v2] -= 1
if ins[v2] == 0:
#print("<--",v2)
q.append(v2)
#print(res[1:])
#print(outs)
#print(ins)
dp = [0]*(v+1)
for i in res[1:]:
for j in outs[i]:
dp[j] = dp[i] + 1
#print(i, j, dp)
print((max(dp))) | """memo
トポロジカルソート「http://zehnpaard.hatenablog.com/entry/2018/06/26/201512」
をしてから，dpで求めた．（ソートと同時にdp求められそう）
"""
from collections import deque, defaultdict
import sys
input == sys.stdin.readline
def main():
v, n = list(map(int, input().split()))
es = [[int(x) for x in input().split()] for _ in range(n)]
outs = defaultdict(list)
ins = defaultdict(int)
#print(ins)
for v1, v2 in es:
outs[v1].append(v2)
ins[v2] += 1
#print(ins)
#print("be",ins)
q = deque(v1 for v1 in range(1,v+1) if ins[v1] == 0) #rangeは無駄なものがない
#print("af",ins)
res = []
#print(outs)
#print(ins)
dp = [0]*(v+1)
while q:
#print(q)
v1 = q.popleft()
res.append(v1)
for v2 in outs[v1]: #v1のノードから出ている矢印をみる．
dp[v2] = dp[v1] + 1
#print("-->",v2)
ins[v2] -= 1
if ins[v2] == 0: #v2のノードに入る矢印をすべて見たときにqに追加
#print("<--",v2)
q.append(v2)
#print(res[1:])
#print(outs)
#print(ins)
print((max(dp)))
if __name__ == '__main__':
main() | 39 | 45 | 804 | 1,142 | from collections import defaultdict, deque
v, n = list(map(int, input().split()))
es = [[int(x) for x in input().split()] for _ in range(n)]
outs = defaultdict(list)
ins = defaultdict(int)
# print(ins)
for v1, v2 in es:
outs[v1].append(v2)
ins[v2] += 1
# print(ins)
# print("be",ins)
q = deque(v1 for v1 in range(v + 1) if ins[v1] == 0)
# print("af",ins)
res = []
# print(outs)
# print(ins)
while q:
# print(q)
v1 = q.popleft()
res.append(v1)
for v2 in outs[v1]:
# print("-->",v2)
ins[v2] -= 1
if ins[v2] == 0:
# print("<--",v2)
q.append(v2)
# print(res[1:])
# print(outs)
# print(ins)
dp = [0] * (v + 1)
for i in res[1:]:
for j in outs[i]:
dp[j] = dp[i] + 1
# print(i, j, dp)
print((max(dp)))
| """memo
トポロジカルソート「http://zehnpaard.hatenablog.com/entry/2018/06/26/201512」
をしてから，dpで求めた．（ソートと同時にdp求められそう）
"""
from collections import deque, defaultdict
import sys
input == sys.stdin.readline
def main():
v, n = list(map(int, input().split()))
es = [[int(x) for x in input().split()] for _ in range(n)]
outs = defaultdict(list)
ins = defaultdict(int)
# print(ins)
for v1, v2 in es:
outs[v1].append(v2)
ins[v2] += 1
# print(ins)
# print("be",ins)
q = deque(v1 for v1 in range(1, v + 1) if ins[v1] == 0) # rangeは無駄なものがない
# print("af",ins)
res = []
# print(outs)
# print(ins)
dp = [0] * (v + 1)
while q:
# print(q)
v1 = q.popleft()
res.append(v1)
for v2 in outs[v1]: # v1のノードから出ている矢印をみる．
dp[v2] = dp[v1] + 1
# print("-->",v2)
ins[v2] -= 1
if ins[v2] == 0: # v2のノードに入る矢印をすべて見たときにqに追加
# print("<--",v2)
q.append(v2)
# print(res[1:])
# print(outs)
# print(ins)
print((max(dp)))
if __name__ == "__main__":
main()
| false | 13.333333 | [
"-from collections import defaultdict, deque",
"+\"\"\"memo",
"+ トポロジカルソート「http://zehnpaard.hatenablog.com/entry/2018/06/26/201512」",
"+ をしてから，dpで求めた．（ソートと同時にdp求められそう）",
"+\"\"\"",
"+from collections import deque, defaultdict",
"+import sys",
"-v, n = list(map(int, input().split()))",
"-es = [[int(x) for x in input().split()] for _ in range(n)]",
"-outs = defaultdict(list)",
"-ins = defaultdict(int)",
"-# print(ins)",
"-for v1, v2 in es:",
"- outs[v1].append(v2)",
"- ins[v2] += 1",
"+input == sys.stdin.readline",
"+",
"+",
"+def main():",
"+ v, n = list(map(int, input().split()))",
"+ es = [[int(x) for x in input().split()] for _ in range(n)]",
"+ outs = defaultdict(list)",
"+ ins = defaultdict(int)",
"-# print(\"be\",ins)",
"-q = deque(v1 for v1 in range(v + 1) if ins[v1] == 0)",
"-# print(\"af\",ins)",
"-res = []",
"-# print(outs)",
"-# print(ins)",
"-while q:",
"- # print(q)",
"- v1 = q.popleft()",
"- res.append(v1)",
"- for v2 in outs[v1]:",
"- # print(\"-->\",v2)",
"- ins[v2] -= 1",
"- if ins[v2] == 0:",
"- # print(\"<--\",v2)",
"- q.append(v2)",
"-# print(res[1:])",
"-# print(outs)",
"-# print(ins)",
"-dp = [0] * (v + 1)",
"-for i in res[1:]:",
"- for j in outs[i]:",
"- dp[j] = dp[i] + 1",
"- # print(i, j, dp)",
"-print((max(dp)))",
"+ for v1, v2 in es:",
"+ outs[v1].append(v2)",
"+ ins[v2] += 1",
"+ # print(ins)",
"+ # print(\"be\",ins)",
"+ q = deque(v1 for v1 in range(1, v + 1) if ins[v1] == 0) # rangeは無駄なものがない",
"+ # print(\"af\",ins)",
"+ res = []",
"+ # print(outs)",
"+ # print(ins)",
"+ dp = [0] * (v + 1)",
"+ while q:",
"+ # print(q)",
"+ v1 = q.popleft()",
"+ res.append(v1)",
"+ for v2 in outs[v1]: # v1のノードから出ている矢印をみる．",
"+ dp[v2] = dp[v1] + 1",
"+ # print(\"-->\",v2)",
"+ ins[v2] -= 1",
"+ if ins[v2] == 0: # v2のノードに入る矢印をすべて見たときにqに追加",
"+ # print(\"<--\",v2)",
"+ q.append(v2)",
"+ # print(res[1:])",
"+ # print(outs)",
"+ # print(ins)",
"+ print((max(dp)))",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
]
| false | 0.075982 | 0.125854 | 0.603735 | [
"s548526948",
"s731781393"
]
|
u342869120 | p03162 | python | s501439378 | s686376119 | 867 | 686 | 123,824 | 74,584 | Accepted | Accepted | 20.88 | import sys
sys.setrecursionlimit(10**8)
N = int(eval(input()))
abc = [list(map(int, input().split())) for i in range(N)]
abc.append([0, 0, 0])
dp = [[-1] * 4 for i in range(N + 1)]
def happy(n, p):
if n < 0:
return 0
if dp[n][p] >= 0:
return dp[n][p]
a = 0 if p == 0 else happy(n - 1, 0) + abc[n][0]
b = 0 if p == 1 else happy(n - 1, 1) + abc[n][1]
c = 0 if p == 2 else happy(n - 1, 2) + abc[n][2]
dp[n][p] = max([a, b, c])
return dp[n][p]
print((happy(N - 1, 3)))
| N = int(eval(input()))
abc = [list(map(int, input().split())) for i in range(N)]
abc.append([0, 0, 0])
dp = [[-1] * 4 for i in range(N + 1)]
dp[0] = [0, 0, 0]
for i in range(1, N + 1):
dp[i][0] = max([dp[i - 1][1] + abc[i - 1][1], dp[i - 1][2] + abc[i - 1][2]])
dp[i][1] = max([dp[i - 1][0] + abc[i - 1][0], dp[i - 1][2] + abc[i - 1][2]])
dp[i][2] = max([dp[i - 1][1] + abc[i - 1][1], dp[i - 1][0] + abc[i - 1][0]])
print((max(dp[N])))
| 25 | 12 | 533 | 453 | import sys
sys.setrecursionlimit(10**8)
N = int(eval(input()))
abc = [list(map(int, input().split())) for i in range(N)]
abc.append([0, 0, 0])
dp = [[-1] * 4 for i in range(N + 1)]
def happy(n, p):
if n < 0:
return 0
if dp[n][p] >= 0:
return dp[n][p]
a = 0 if p == 0 else happy(n - 1, 0) + abc[n][0]
b = 0 if p == 1 else happy(n - 1, 1) + abc[n][1]
c = 0 if p == 2 else happy(n - 1, 2) + abc[n][2]
dp[n][p] = max([a, b, c])
return dp[n][p]
print((happy(N - 1, 3)))
| N = int(eval(input()))
abc = [list(map(int, input().split())) for i in range(N)]
abc.append([0, 0, 0])
dp = [[-1] * 4 for i in range(N + 1)]
dp[0] = [0, 0, 0]
for i in range(1, N + 1):
dp[i][0] = max([dp[i - 1][1] + abc[i - 1][1], dp[i - 1][2] + abc[i - 1][2]])
dp[i][1] = max([dp[i - 1][0] + abc[i - 1][0], dp[i - 1][2] + abc[i - 1][2]])
dp[i][2] = max([dp[i - 1][1] + abc[i - 1][1], dp[i - 1][0] + abc[i - 1][0]])
print((max(dp[N])))
| false | 52 | [
"-import sys",
"-",
"-sys.setrecursionlimit(10**8)",
"-",
"-",
"-def happy(n, p):",
"- if n < 0:",
"- return 0",
"- if dp[n][p] >= 0:",
"- return dp[n][p]",
"- a = 0 if p == 0 else happy(n - 1, 0) + abc[n][0]",
"- b = 0 if p == 1 else happy(n - 1, 1) + abc[n][1]",
"- c = 0 if p == 2 else happy(n - 1, 2) + abc[n][2]",
"- dp[n][p] = max([a, b, c])",
"- return dp[n][p]",
"-",
"-",
"-print((happy(N - 1, 3)))",
"+dp[0] = [0, 0, 0]",
"+for i in range(1, N + 1):",
"+ dp[i][0] = max([dp[i - 1][1] + abc[i - 1][1], dp[i - 1][2] + abc[i - 1][2]])",
"+ dp[i][1] = max([dp[i - 1][0] + abc[i - 1][0], dp[i - 1][2] + abc[i - 1][2]])",
"+ dp[i][2] = max([dp[i - 1][1] + abc[i - 1][1], dp[i - 1][0] + abc[i - 1][0]])",
"+print((max(dp[N])))"
]
| false | 0.133503 | 0.040841 | 3.268882 | [
"s501439378",
"s686376119"
]
|
u401452016 | p02844 | python | s219849752 | s833960895 | 1,844 | 22 | 68,504 | 3,064 | Accepted | Accepted | 98.81 | #三井住友2019 D 貪欲法
def main():
import sys
N = int(sys.stdin.readline())
S = sys.stdin.readline().rstrip()
ans = 0
for i in range(1000):
num = str(i).zfill(3)
L = []
k = 0
for j in range(N):
#print(num, S[j])
if int(S[j])==int(num[k]):
#print('Yes', num)
L.append(S[j])
k+=1
if len(L)==3:
#print(L)
ans +=1
break
print(ans)
if __name__=='__main__':
main()
| #三井住友2019 D
def main():
import sys
N = int(sys.stdin.readline())
S = sys.stdin.readline().rstrip()
cnt = 0
for i in range(0, 10):
for j in range(0, 10):
for k in range(0, 10):
st1 = S.find(str(i))
if st1 ==-1:
continue
st2 = S[st1+1:].find(str(j))
if st2 ==-1:
continue
st3 = S[st1+st2+2:].find(str(k))
if st3 ==-1:
continue
#print(st1,st2,st3, i,j,k)
cnt +=1
print(cnt)
if __name__=='__main__':
main() | 26 | 31 | 600 | 737 | # 三井住友2019 D 貪欲法
def main():
import sys
N = int(sys.stdin.readline())
S = sys.stdin.readline().rstrip()
ans = 0
for i in range(1000):
num = str(i).zfill(3)
L = []
k = 0
for j in range(N):
# print(num, S[j])
if int(S[j]) == int(num[k]):
# print('Yes', num)
L.append(S[j])
k += 1
if len(L) == 3:
# print(L)
ans += 1
break
print(ans)
if __name__ == "__main__":
main()
| # 三井住友2019 D
def main():
import sys
N = int(sys.stdin.readline())
S = sys.stdin.readline().rstrip()
cnt = 0
for i in range(0, 10):
for j in range(0, 10):
for k in range(0, 10):
st1 = S.find(str(i))
if st1 == -1:
continue
st2 = S[st1 + 1 :].find(str(j))
if st2 == -1:
continue
st3 = S[st1 + st2 + 2 :].find(str(k))
if st3 == -1:
continue
# print(st1,st2,st3, i,j,k)
cnt += 1
print(cnt)
if __name__ == "__main__":
main()
| false | 16.129032 | [
"-# 三井住友2019 D 貪欲法",
"+# 三井住友2019 D",
"- ans = 0",
"- for i in range(1000):",
"- num = str(i).zfill(3)",
"- L = []",
"- k = 0",
"- for j in range(N):",
"- # print(num, S[j])",
"- if int(S[j]) == int(num[k]):",
"- # print('Yes', num)",
"- L.append(S[j])",
"- k += 1",
"- if len(L) == 3:",
"- # print(L)",
"- ans += 1",
"- break",
"- print(ans)",
"+ cnt = 0",
"+ for i in range(0, 10):",
"+ for j in range(0, 10):",
"+ for k in range(0, 10):",
"+ st1 = S.find(str(i))",
"+ if st1 == -1:",
"+ continue",
"+ st2 = S[st1 + 1 :].find(str(j))",
"+ if st2 == -1:",
"+ continue",
"+ st3 = S[st1 + st2 + 2 :].find(str(k))",
"+ if st3 == -1:",
"+ continue",
"+ # print(st1,st2,st3, i,j,k)",
"+ cnt += 1",
"+ print(cnt)"
]
| false | 0.059709 | 0.041467 | 1.439918 | [
"s219849752",
"s833960895"
]
|
u577170763 | p03162 | python | s844848780 | s702821808 | 665 | 308 | 59,500 | 53,612 | Accepted | Accepted | 53.68 | # import sys
# sys.setrecursionlimit(10**5)
# from collections import defaultdict
geta = lambda fn: list(map(fn, input().split()))
gete = lambda fn: fn(eval(input()))
def main():
n=gete(int)
dp=[[0]*3 for _ in range(n+1)]
for i in range(n):
a,b,c = list(map(int, input().split()))
dp[i+1][0] = max(dp[i][1], dp[i][2]) + a
dp[i+1][1] = max(dp[i][2], dp[i][0]) + b
dp[i+1][2] = max(dp[i][0], dp[i][1]) + c
print((max(dp[n][0],dp[n][1],dp[n][2])))
if __name__ == "__main__":
main() | # import sys
# sys.setrecursionlimit(10**5)
# from collections import defaultdict
import sys
readline = sys.stdin.buffer.readline
geta = lambda fn: list(map(fn, readline().split()))
gete = lambda fn: fn(readline())
def main():
n=gete(int)
dp=[[0]*3 for _ in range(n+1)]
for i in range(n):
a,b,c = geta(int)
dp[i+1][0] = max(dp[i][1], dp[i][2]) + a
dp[i+1][1] = max(dp[i][2], dp[i][0]) + b
dp[i+1][2] = max(dp[i][0], dp[i][1]) + c
print((max(dp[n][0],dp[n][1],dp[n][2])))
if __name__ == "__main__":
main() | 23 | 25 | 507 | 547 | # import sys
# sys.setrecursionlimit(10**5)
# from collections import defaultdict
geta = lambda fn: list(map(fn, input().split()))
gete = lambda fn: fn(eval(input()))
def main():
n = gete(int)
dp = [[0] * 3 for _ in range(n + 1)]
for i in range(n):
a, b, c = list(map(int, input().split()))
dp[i + 1][0] = max(dp[i][1], dp[i][2]) + a
dp[i + 1][1] = max(dp[i][2], dp[i][0]) + b
dp[i + 1][2] = max(dp[i][0], dp[i][1]) + c
print((max(dp[n][0], dp[n][1], dp[n][2])))
if __name__ == "__main__":
main()
| # import sys
# sys.setrecursionlimit(10**5)
# from collections import defaultdict
import sys
readline = sys.stdin.buffer.readline
geta = lambda fn: list(map(fn, readline().split()))
gete = lambda fn: fn(readline())
def main():
n = gete(int)
dp = [[0] * 3 for _ in range(n + 1)]
for i in range(n):
a, b, c = geta(int)
dp[i + 1][0] = max(dp[i][1], dp[i][2]) + a
dp[i + 1][1] = max(dp[i][2], dp[i][0]) + b
dp[i + 1][2] = max(dp[i][0], dp[i][1]) + c
print((max(dp[n][0], dp[n][1], dp[n][2])))
if __name__ == "__main__":
main()
| false | 8 | [
"-geta = lambda fn: list(map(fn, input().split()))",
"-gete = lambda fn: fn(eval(input()))",
"+import sys",
"+",
"+readline = sys.stdin.buffer.readline",
"+geta = lambda fn: list(map(fn, readline().split()))",
"+gete = lambda fn: fn(readline())",
"- a, b, c = list(map(int, input().split()))",
"+ a, b, c = geta(int)"
]
| false | 0.036464 | 0.04546 | 0.8021 | [
"s844848780",
"s702821808"
]
|
u298297089 | p03786 | python | s204859054 | s823765306 | 135 | 114 | 14,428 | 14,320 | Accepted | Accepted | 15.56 | n = int(eval(input()))
from itertools import accumulate
a = sorted(map(int, input().split()))
acc = list(accumulate(a))[::-1]
a = a[::-1]
ans = 1
for i in range(n-1):
if acc[i] > a[i+1]*2 and a[i] > acc[i+1]*2:
break
ans += 1
print(ans)
| n = int(eval(input()))
a = sorted(map(int, input().split()))
acc = 0
ans = 0
for i in range(n):
if acc * 2 >= a[i]:
ans += 1
else:
ans = 1
acc += a[i]
print(ans)
| 12 | 15 | 259 | 202 | n = int(eval(input()))
from itertools import accumulate
a = sorted(map(int, input().split()))
acc = list(accumulate(a))[::-1]
a = a[::-1]
ans = 1
for i in range(n - 1):
if acc[i] > a[i + 1] * 2 and a[i] > acc[i + 1] * 2:
break
ans += 1
print(ans)
| n = int(eval(input()))
a = sorted(map(int, input().split()))
acc = 0
ans = 0
for i in range(n):
if acc * 2 >= a[i]:
ans += 1
else:
ans = 1
acc += a[i]
print(ans)
| false | 20 | [
"-from itertools import accumulate",
"-",
"-acc = list(accumulate(a))[::-1]",
"-a = a[::-1]",
"-ans = 1",
"-for i in range(n - 1):",
"- if acc[i] > a[i + 1] * 2 and a[i] > acc[i + 1] * 2:",
"- break",
"- ans += 1",
"+acc = 0",
"+ans = 0",
"+for i in range(n):",
"+ if acc * 2 >= a[i]:",
"+ ans += 1",
"+ else:",
"+ ans = 1",
"+ acc += a[i]"
]
| false | 0.110607 | 0.039176 | 2.823329 | [
"s204859054",
"s823765306"
]
|
u903005414 | p03380 | python | s470802929 | s947007952 | 469 | 249 | 32,516 | 23,032 | Accepted | Accepted | 46.91 | import numpy as np
n = int(eval(input()))
a = np.array(list(map(int, input().split())))
a.sort()
ai = a.max()
v, aj = 0, 0
for i in a[:-1]:
tmp = i * (ai - i)
if v < tmp:
v = tmp
aj = i
# print(v, aj)
print(ai)
print(aj)
| import numpy as np
n = int(eval(input()))
a = np.array(list(map(int, input().split())))
ai = a.max()
v, aj = 0, 0
for i in a:
tmp = i * (ai - i)
if v < tmp:
v = tmp
aj = i
# print(v, aj)
print((*(ai, aj)))
| 17 | 14 | 258 | 237 | import numpy as np
n = int(eval(input()))
a = np.array(list(map(int, input().split())))
a.sort()
ai = a.max()
v, aj = 0, 0
for i in a[:-1]:
tmp = i * (ai - i)
if v < tmp:
v = tmp
aj = i
# print(v, aj)
print(ai)
print(aj)
| import numpy as np
n = int(eval(input()))
a = np.array(list(map(int, input().split())))
ai = a.max()
v, aj = 0, 0
for i in a:
tmp = i * (ai - i)
if v < tmp:
v = tmp
aj = i
# print(v, aj)
print((*(ai, aj)))
| false | 17.647059 | [
"-a.sort()",
"-for i in a[:-1]:",
"+for i in a:",
"-print(ai)",
"-print(aj)",
"+print((*(ai, aj)))"
]
| false | 0.181571 | 0.319179 | 0.568868 | [
"s470802929",
"s947007952"
]
|
u667084803 | p03111 | python | s930250628 | s193742479 | 429 | 373 | 4,996 | 3,188 | Accepted | Accepted | 13.05 | #https://atcoder.jp/contests/abc119/tasks/abc119_c
#2019-02-24
N, A, B, C = list(map(int, input().split()))
l = [int(eval(input())) for _ in range(N)]
ans = []
# 00 なら使わない、 01 ならAをつくる、10 ならBをつくる、11ならCをつくる
for i in range(1 << 2*N):
A_hon = 0
B_hon = 0
C_hon = 0
A_zai = 0
B_zai = 0
C_zai = 0
for k in range(N):
if i & (1<<(2*k)) and i & (1<< (2*k)+1):
C_hon += 1
C_zai += l[k]
elif i & (1<<(2*k)+1):
B_hon += 1
B_zai += l[k]
elif i & (1<<(2*k)):
A_hon += 1
A_zai += l[k]
if A_hon * B_hon * C_hon >0:
ans += [10*(A_hon - 1)+ abs(A_zai - A)+10*(B_hon - 1)+ abs(B_zai - B)+ 10*(C_hon - 1)+ abs(C_zai - C)]
print((min(ans))) | import itertools
N, *A = list(map(int,input().split()))
l = [int(eval(input())) for i in range(N)]
li = itertools.product(list(range(4)), repeat=N)
ans = float("inf")
for i in li:
cnt = [0]*3
length = [0]*3
for k in range(N):
if i[k] == 3:
continue
cnt[i[k]] += 1
length[i[k]] += l[k]
if min(cnt) > 0:
cost = sum([abs(length[i]-A[i]) +10*cnt[i] for i in range(3)]) -30
ans = min(ans, cost)
print(ans) | 28 | 19 | 770 | 440 | # https://atcoder.jp/contests/abc119/tasks/abc119_c
# 2019-02-24
N, A, B, C = list(map(int, input().split()))
l = [int(eval(input())) for _ in range(N)]
ans = []
# 00 なら使わない、 01 ならAをつくる、10 ならBをつくる、11ならCをつくる
for i in range(1 << 2 * N):
A_hon = 0
B_hon = 0
C_hon = 0
A_zai = 0
B_zai = 0
C_zai = 0
for k in range(N):
if i & (1 << (2 * k)) and i & (1 << (2 * k) + 1):
C_hon += 1
C_zai += l[k]
elif i & (1 << (2 * k) + 1):
B_hon += 1
B_zai += l[k]
elif i & (1 << (2 * k)):
A_hon += 1
A_zai += l[k]
if A_hon * B_hon * C_hon > 0:
ans += [
10 * (A_hon - 1)
+ abs(A_zai - A)
+ 10 * (B_hon - 1)
+ abs(B_zai - B)
+ 10 * (C_hon - 1)
+ abs(C_zai - C)
]
print((min(ans)))
| import itertools
N, *A = list(map(int, input().split()))
l = [int(eval(input())) for i in range(N)]
li = itertools.product(list(range(4)), repeat=N)
ans = float("inf")
for i in li:
cnt = [0] * 3
length = [0] * 3
for k in range(N):
if i[k] == 3:
continue
cnt[i[k]] += 1
length[i[k]] += l[k]
if min(cnt) > 0:
cost = sum([abs(length[i] - A[i]) + 10 * cnt[i] for i in range(3)]) - 30
ans = min(ans, cost)
print(ans)
| false | 32.142857 | [
"-# https://atcoder.jp/contests/abc119/tasks/abc119_c",
"-# 2019-02-24",
"-N, A, B, C = list(map(int, input().split()))",
"-l = [int(eval(input())) for _ in range(N)]",
"-ans = []",
"-# 00 なら使わない、 01 ならAをつくる、10 ならBをつくる、11ならCをつくる",
"-for i in range(1 << 2 * N):",
"- A_hon = 0",
"- B_hon = 0",
"- C_hon = 0",
"- A_zai = 0",
"- B_zai = 0",
"- C_zai = 0",
"+import itertools",
"+",
"+N, *A = list(map(int, input().split()))",
"+l = [int(eval(input())) for i in range(N)]",
"+li = itertools.product(list(range(4)), repeat=N)",
"+ans = float(\"inf\")",
"+for i in li:",
"+ cnt = [0] * 3",
"+ length = [0] * 3",
"- if i & (1 << (2 * k)) and i & (1 << (2 * k) + 1):",
"- C_hon += 1",
"- C_zai += l[k]",
"- elif i & (1 << (2 * k) + 1):",
"- B_hon += 1",
"- B_zai += l[k]",
"- elif i & (1 << (2 * k)):",
"- A_hon += 1",
"- A_zai += l[k]",
"- if A_hon * B_hon * C_hon > 0:",
"- ans += [",
"- 10 * (A_hon - 1)",
"- + abs(A_zai - A)",
"- + 10 * (B_hon - 1)",
"- + abs(B_zai - B)",
"- + 10 * (C_hon - 1)",
"- + abs(C_zai - C)",
"- ]",
"-print((min(ans)))",
"+ if i[k] == 3:",
"+ continue",
"+ cnt[i[k]] += 1",
"+ length[i[k]] += l[k]",
"+ if min(cnt) > 0:",
"+ cost = sum([abs(length[i] - A[i]) + 10 * cnt[i] for i in range(3)]) - 30",
"+ ans = min(ans, cost)",
"+print(ans)"
]
| false | 0.882317 | 0.233955 | 3.771309 | [
"s930250628",
"s193742479"
]
|
u119148115 | p02600 | python | s062158679 | s693766994 | 89 | 68 | 61,772 | 61,784 | Accepted | Accepted | 23.6 | import sys
sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
def LI2(): return list(map(int,sys.stdin.readline().rstrip())) #空白なし
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split()) #空白あり
def LS2(): return list(sys.stdin.readline().rstrip()) #空白なし
X = I()
if X < 600:
print((8))
else:
print((10-X//200))
| import sys
def I(): return int(sys.stdin.readline().rstrip())
print((10-I()//200))
| 16 | 4 | 554 | 85 | import sys
sys.setrecursionlimit(10**7)
def I():
return int(sys.stdin.readline().rstrip())
def MI():
return list(map(int, sys.stdin.readline().rstrip().split()))
def LI():
return list(map(int, sys.stdin.readline().rstrip().split())) # 空白あり
def LI2():
return list(map(int, sys.stdin.readline().rstrip())) # 空白なし
def S():
return sys.stdin.readline().rstrip()
def LS():
return list(sys.stdin.readline().rstrip().split()) # 空白あり
def LS2():
return list(sys.stdin.readline().rstrip()) # 空白なし
X = I()
if X < 600:
print((8))
else:
print((10 - X // 200))
| import sys
def I():
return int(sys.stdin.readline().rstrip())
print((10 - I() // 200))
| false | 75 | [
"-",
"-sys.setrecursionlimit(10**7)",
"-def MI():",
"- return list(map(int, sys.stdin.readline().rstrip().split()))",
"-",
"-",
"-def LI():",
"- return list(map(int, sys.stdin.readline().rstrip().split())) # 空白あり",
"-",
"-",
"-def LI2():",
"- return list(map(int, sys.stdin.readline().rstrip())) # 空白なし",
"-",
"-",
"-def S():",
"- return sys.stdin.readline().rstrip()",
"-",
"-",
"-def LS():",
"- return list(sys.stdin.readline().rstrip().split()) # 空白あり",
"-",
"-",
"-def LS2():",
"- return list(sys.stdin.readline().rstrip()) # 空白なし",
"-",
"-",
"-X = I()",
"-if X < 600:",
"- print((8))",
"-else:",
"- print((10 - X // 200))",
"+print((10 - I() // 200))"
]
| false | 0.044812 | 0.044776 | 1.00081 | [
"s062158679",
"s693766994"
]
|
u699089116 | p03632 | python | s193591333 | s776054325 | 27 | 23 | 9,116 | 9,076 | Accepted | Accepted | 14.81 | a, b, c, d = list(map(int, input().split()))
table = [0] * 101
for i in range(a, b+1):
table[i] += 1
for j in range(c, d+1):
table[j] += 1
print((table.count(2) if table.count(2) == 0 else table.count(2)-1)) | a, b, c, d = list(map(int, input().split()))
table = [0] * 101
for i in range(a, b):
table[i] += 1
for j in range(c, d):
table[j] += 1
print((table.count(2))) | 10 | 10 | 219 | 170 | a, b, c, d = list(map(int, input().split()))
table = [0] * 101
for i in range(a, b + 1):
table[i] += 1
for j in range(c, d + 1):
table[j] += 1
print((table.count(2) if table.count(2) == 0 else table.count(2) - 1))
| a, b, c, d = list(map(int, input().split()))
table = [0] * 101
for i in range(a, b):
table[i] += 1
for j in range(c, d):
table[j] += 1
print((table.count(2)))
| false | 0 | [
"-for i in range(a, b + 1):",
"+for i in range(a, b):",
"-for j in range(c, d + 1):",
"+for j in range(c, d):",
"-print((table.count(2) if table.count(2) == 0 else table.count(2) - 1))",
"+print((table.count(2)))"
]
| false | 0.041967 | 0.050886 | 0.824726 | [
"s193591333",
"s776054325"
]
|
u102461423 | p03321 | python | s521678999 | s237763338 | 610 | 507 | 36,720 | 35,948 | Accepted | Accepted | 16.89 | import sys
input = sys.stdin.readline
from collections import defaultdict
# 切り離す必要があるものを辺として、二部グラフの判定
N,M = list(map(int,input().split()))
# 補グラフ
graph = [set(x for x in range(N) if x != y) for y in range(N)]
for _ in range(M):
a,b = [int(x) - 1 for x in input().split()]
graph[a].remove(b)
graph[b].remove(a)
color = [None] * N
size = defaultdict(lambda: [0,0])
def set_color(root,x,c):
size[root][c] += 1
color[x] = c
for y in graph[x]:
if color[y] is None:
set_color(root,y,1-c)
elif color[y] == color[x]:
print((-1))
exit()
for x in range(N):
if color[x] is None:
set_color(x,x,0)
# 二部グラフになるべく平均的に分けたい
# 可能なサイズの集合を持つ
se = {0}
for x,y in list(size.values()):
se = set(s + x for s in se) | set(s + y for s in se)
answer = min(x*(x-1)//2+(N-x)*(N-x-1)//2 for x in se)
print(answer) | import sys
input = sys.stdin.readline
from collections import defaultdict
# 切り離す必要があるものを辺として、二部グラフの判定
N,M = list(map(int,input().split()))
# 補グラフ
rng = list(range(1,N+1))
graph = [None] + [set(x for x in rng if x != y) for y in rng]
for _ in range(M):
a,b = list(map(int,input().split()))
graph[a].remove(b)
graph[b].remove(a)
color = [None] * (1+N)
size = defaultdict(lambda: [0,0])
def set_color(root,x,c):
size[root][c] += 1
color[x] = c
for y in graph[x]:
if color[y] is None:
set_color(root,y,1-c)
elif color[y] == color[x]:
print((-1))
exit()
for x in rng:
if color[x] is None:
set_color(x,x,0)
# 二部グラフになるべく平均的に分けたい
# 可能なサイズの集合を持つ
se = {0}
for x,y in list(size.values()):
se = set(s + x for s in se) | set(s + y for s in se)
answer = min(x*(x-1)//2+(N-x)*(N-x-1)//2 for x in se)
print(answer) | 40 | 41 | 911 | 912 | import sys
input = sys.stdin.readline
from collections import defaultdict
# 切り離す必要があるものを辺として、二部グラフの判定
N, M = list(map(int, input().split()))
# 補グラフ
graph = [set(x for x in range(N) if x != y) for y in range(N)]
for _ in range(M):
a, b = [int(x) - 1 for x in input().split()]
graph[a].remove(b)
graph[b].remove(a)
color = [None] * N
size = defaultdict(lambda: [0, 0])
def set_color(root, x, c):
size[root][c] += 1
color[x] = c
for y in graph[x]:
if color[y] is None:
set_color(root, y, 1 - c)
elif color[y] == color[x]:
print((-1))
exit()
for x in range(N):
if color[x] is None:
set_color(x, x, 0)
# 二部グラフになるべく平均的に分けたい
# 可能なサイズの集合を持つ
se = {0}
for x, y in list(size.values()):
se = set(s + x for s in se) | set(s + y for s in se)
answer = min(x * (x - 1) // 2 + (N - x) * (N - x - 1) // 2 for x in se)
print(answer)
| import sys
input = sys.stdin.readline
from collections import defaultdict
# 切り離す必要があるものを辺として、二部グラフの判定
N, M = list(map(int, input().split()))
# 補グラフ
rng = list(range(1, N + 1))
graph = [None] + [set(x for x in rng if x != y) for y in rng]
for _ in range(M):
a, b = list(map(int, input().split()))
graph[a].remove(b)
graph[b].remove(a)
color = [None] * (1 + N)
size = defaultdict(lambda: [0, 0])
def set_color(root, x, c):
size[root][c] += 1
color[x] = c
for y in graph[x]:
if color[y] is None:
set_color(root, y, 1 - c)
elif color[y] == color[x]:
print((-1))
exit()
for x in rng:
if color[x] is None:
set_color(x, x, 0)
# 二部グラフになるべく平均的に分けたい
# 可能なサイズの集合を持つ
se = {0}
for x, y in list(size.values()):
se = set(s + x for s in se) | set(s + y for s in se)
answer = min(x * (x - 1) // 2 + (N - x) * (N - x - 1) // 2 for x in se)
print(answer)
| false | 2.439024 | [
"-graph = [set(x for x in range(N) if x != y) for y in range(N)]",
"+rng = list(range(1, N + 1))",
"+graph = [None] + [set(x for x in rng if x != y) for y in rng]",
"- a, b = [int(x) - 1 for x in input().split()]",
"+ a, b = list(map(int, input().split()))",
"-color = [None] * N",
"+color = [None] * (1 + N)",
"-for x in range(N):",
"+for x in rng:"
]
| false | 0.042281 | 0.043772 | 0.965933 | [
"s521678999",
"s237763338"
]
|
u125545880 | p02861 | python | s247657167 | s595835713 | 470 | 79 | 30,268 | 4,460 | Accepted | Accepted | 83.19 | # coding UTF-8
#
# problem C
#
import itertools
import numpy as np
from scipy.spatial import distance
N = int(eval(input()))
city = []
for i in range(N):
city.append(list(map(int, input().split())))
d = distance.cdist(city, city, metric='euclidean')
ans = []
city_no = list(range(N))
for elem in itertools.permutations(city_no, N):
for j in range(len(elem)-1):
ans.append(d[elem[j], elem[j+1]])
print(((sum(ans)/len(ans))*(N-1)))
| import sys
import math
import itertools
readline = sys.stdin.readline
sqrt = math.sqrt
def euclid_distance(a, b):
return sqrt(pow(a[0]-b[0],2) + pow(a[1]-b[1],2))
def main():
N = int(eval(input()))
A = []
for _ in range(N):
A.append(tuple(map(int, readline().split())))
D = []
for i in range(N):
tmp = []
for j in range(N):
tmp.append(euclid_distance(A[i], A[j]))
D.append(tmp)
distance = []
for root in itertools.permutations(list(range(N))):
dsum = 0
for r in range(N-1):
dsum += D[root[r]][root[r+1]]
distance.append(dsum)
ans = sum(distance)/len(distance)
print(ans)
if __name__ == "__main__":
main()
| 22 | 36 | 465 | 772 | # coding UTF-8
#
# problem C
#
import itertools
import numpy as np
from scipy.spatial import distance
N = int(eval(input()))
city = []
for i in range(N):
city.append(list(map(int, input().split())))
d = distance.cdist(city, city, metric="euclidean")
ans = []
city_no = list(range(N))
for elem in itertools.permutations(city_no, N):
for j in range(len(elem) - 1):
ans.append(d[elem[j], elem[j + 1]])
print(((sum(ans) / len(ans)) * (N - 1)))
| import sys
import math
import itertools
readline = sys.stdin.readline
sqrt = math.sqrt
def euclid_distance(a, b):
return sqrt(pow(a[0] - b[0], 2) + pow(a[1] - b[1], 2))
def main():
N = int(eval(input()))
A = []
for _ in range(N):
A.append(tuple(map(int, readline().split())))
D = []
for i in range(N):
tmp = []
for j in range(N):
tmp.append(euclid_distance(A[i], A[j]))
D.append(tmp)
distance = []
for root in itertools.permutations(list(range(N))):
dsum = 0
for r in range(N - 1):
dsum += D[root[r]][root[r + 1]]
distance.append(dsum)
ans = sum(distance) / len(distance)
print(ans)
if __name__ == "__main__":
main()
| false | 38.888889 | [
"-# coding UTF-8",
"-#",
"-# problem C",
"-#",
"+import sys",
"+import math",
"-import numpy as np",
"-from scipy.spatial import distance",
"-N = int(eval(input()))",
"-city = []",
"-for i in range(N):",
"- city.append(list(map(int, input().split())))",
"-d = distance.cdist(city, city, metric=\"euclidean\")",
"-ans = []",
"-city_no = list(range(N))",
"-for elem in itertools.permutations(city_no, N):",
"- for j in range(len(elem) - 1):",
"- ans.append(d[elem[j], elem[j + 1]])",
"-print(((sum(ans) / len(ans)) * (N - 1)))",
"+readline = sys.stdin.readline",
"+sqrt = math.sqrt",
"+",
"+",
"+def euclid_distance(a, b):",
"+ return sqrt(pow(a[0] - b[0], 2) + pow(a[1] - b[1], 2))",
"+",
"+",
"+def main():",
"+ N = int(eval(input()))",
"+ A = []",
"+ for _ in range(N):",
"+ A.append(tuple(map(int, readline().split())))",
"+ D = []",
"+ for i in range(N):",
"+ tmp = []",
"+ for j in range(N):",
"+ tmp.append(euclid_distance(A[i], A[j]))",
"+ D.append(tmp)",
"+ distance = []",
"+ for root in itertools.permutations(list(range(N))):",
"+ dsum = 0",
"+ for r in range(N - 1):",
"+ dsum += D[root[r]][root[r + 1]]",
"+ distance.append(dsum)",
"+ ans = sum(distance) / len(distance)",
"+ print(ans)",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
]
| false | 0.778734 | 0.042062 | 18.513983 | [
"s247657167",
"s595835713"
]
|
u349449706 | p02548 | python | s628804327 | s440231967 | 77 | 66 | 62,924 | 62,904 | Accepted | Accepted | 14.29 | N = int(eval(input()))
a = 0
for A in range(1,N+1):
a+=(N-1)//A
print(a)
| N=int(eval(input()))
a = 0
for A in range(1, N):
# for B in range(1, N):
# for C in range(1, N):
# if A*B+C==N:
# a += 1
a += (N-1)//A
print(a) | 5 | 9 | 75 | 163 | N = int(eval(input()))
a = 0
for A in range(1, N + 1):
a += (N - 1) // A
print(a)
| N = int(eval(input()))
a = 0
for A in range(1, N):
# for B in range(1, N):
# for C in range(1, N):
# if A*B+C==N:
# a += 1
a += (N - 1) // A
print(a)
| false | 44.444444 | [
"-for A in range(1, N + 1):",
"+for A in range(1, N):",
"+ # for B in range(1, N):",
"+ # for C in range(1, N):",
"+ # if A*B+C==N:",
"+ # a += 1"
]
| false | 0.070997 | 0.070788 | 1.002952 | [
"s628804327",
"s440231967"
]
|
u492026192 | p02782 | python | s458347713 | s663613493 | 413 | 284 | 55,788 | 71,404 | Accepted | Accepted | 31.23 | r1,c1,r2,c2=list(map(int,input().split()))
MOD=10**9+7
idx=r2+c2+3
perm=[1]*(idx+1)
for i in range(1,idx+1):
perm[i]=perm[i-1]*i
perm[i]%=MOD
def inv_mod(a):
return pow(a,MOD-2,MOD)
def comb(n,m,p=10**9+7):
if n < m : return 0
if n < 0 or m < 0:return 0
m = min(m, n-m)
top = bot = 1
for i in range(m):
top = top*(n-i) % p
bot = bot*(i+1) % p
bot = pow(bot, p-2, p)
return top*bot % p
def g(i,j):
return comb(i+j+2,i+1,MOD)
def s(n,m):
return comb(n+m+2, m+1, MOD)
res=g(r2,c2)-g(r2,c1-1)-g(r1-1,c2)+g(r1-1,c1-1)
res%=MOD
ans = s(r2,c2) - s(r2, c1-1) - s(r1-1, c2) + s(r1-1, c1-1)
ans %= MOD
print(res) | r1,c1,r2,c2=list(map(int,input().split()))
MOD=10**9+7
idx=r2+c2+2
perm=[1]*(idx+1)
perm_inv=[1]*(idx+1)
for i in range(1,idx+1):
perm[i]=perm[i-1]*i
perm[i]%=MOD
def inv_mod(a):
return pow(a,MOD-2,MOD)
perm_inv[-1]=inv_mod(perm[-1])
for i in range(idx-1,-1,-1):
perm_inv[i]=perm_inv[i+1]*(i+1)
perm_inv[i]%=MOD
def comb(i,j):
buf=perm[i+j+2]
buf*=perm_inv[i+1]
buf%=MOD
buf*=perm_inv[j+1]
buf%=MOD
return buf
res=comb(r2,c2)
res-=comb(r2,c1-1)
res-=comb(r1-1,c2)
res+=comb(r1-1,c1-1)
print((res%MOD))
| 30 | 26 | 689 | 561 | r1, c1, r2, c2 = list(map(int, input().split()))
MOD = 10**9 + 7
idx = r2 + c2 + 3
perm = [1] * (idx + 1)
for i in range(1, idx + 1):
perm[i] = perm[i - 1] * i
perm[i] %= MOD
def inv_mod(a):
return pow(a, MOD - 2, MOD)
def comb(n, m, p=10**9 + 7):
if n < m:
return 0
if n < 0 or m < 0:
return 0
m = min(m, n - m)
top = bot = 1
for i in range(m):
top = top * (n - i) % p
bot = bot * (i + 1) % p
bot = pow(bot, p - 2, p)
return top * bot % p
def g(i, j):
return comb(i + j + 2, i + 1, MOD)
def s(n, m):
return comb(n + m + 2, m + 1, MOD)
res = g(r2, c2) - g(r2, c1 - 1) - g(r1 - 1, c2) + g(r1 - 1, c1 - 1)
res %= MOD
ans = s(r2, c2) - s(r2, c1 - 1) - s(r1 - 1, c2) + s(r1 - 1, c1 - 1)
ans %= MOD
print(res)
| r1, c1, r2, c2 = list(map(int, input().split()))
MOD = 10**9 + 7
idx = r2 + c2 + 2
perm = [1] * (idx + 1)
perm_inv = [1] * (idx + 1)
for i in range(1, idx + 1):
perm[i] = perm[i - 1] * i
perm[i] %= MOD
def inv_mod(a):
return pow(a, MOD - 2, MOD)
perm_inv[-1] = inv_mod(perm[-1])
for i in range(idx - 1, -1, -1):
perm_inv[i] = perm_inv[i + 1] * (i + 1)
perm_inv[i] %= MOD
def comb(i, j):
buf = perm[i + j + 2]
buf *= perm_inv[i + 1]
buf %= MOD
buf *= perm_inv[j + 1]
buf %= MOD
return buf
res = comb(r2, c2)
res -= comb(r2, c1 - 1)
res -= comb(r1 - 1, c2)
res += comb(r1 - 1, c1 - 1)
print((res % MOD))
| false | 13.333333 | [
"-idx = r2 + c2 + 3",
"+idx = r2 + c2 + 2",
"+perm_inv = [1] * (idx + 1)",
"-def comb(n, m, p=10**9 + 7):",
"- if n < m:",
"- return 0",
"- if n < 0 or m < 0:",
"- return 0",
"- m = min(m, n - m)",
"- top = bot = 1",
"- for i in range(m):",
"- top = top * (n - i) % p",
"- bot = bot * (i + 1) % p",
"- bot = pow(bot, p - 2, p)",
"- return top * bot % p",
"+perm_inv[-1] = inv_mod(perm[-1])",
"+for i in range(idx - 1, -1, -1):",
"+ perm_inv[i] = perm_inv[i + 1] * (i + 1)",
"+ perm_inv[i] %= MOD",
"-def g(i, j):",
"- return comb(i + j + 2, i + 1, MOD)",
"+def comb(i, j):",
"+ buf = perm[i + j + 2]",
"+ buf *= perm_inv[i + 1]",
"+ buf %= MOD",
"+ buf *= perm_inv[j + 1]",
"+ buf %= MOD",
"+ return buf",
"-def s(n, m):",
"- return comb(n + m + 2, m + 1, MOD)",
"-",
"-",
"-res = g(r2, c2) - g(r2, c1 - 1) - g(r1 - 1, c2) + g(r1 - 1, c1 - 1)",
"-res %= MOD",
"-ans = s(r2, c2) - s(r2, c1 - 1) - s(r1 - 1, c2) + s(r1 - 1, c1 - 1)",
"-ans %= MOD",
"-print(res)",
"+res = comb(r2, c2)",
"+res -= comb(r2, c1 - 1)",
"+res -= comb(r1 - 1, c2)",
"+res += comb(r1 - 1, c1 - 1)",
"+print((res % MOD))"
]
| false | 0.089509 | 0.092633 | 0.966273 | [
"s458347713",
"s663613493"
]
|
u057109575 | p02774 | python | s142154628 | s667595274 | 693 | 421 | 97,928 | 108,236 | Accepted | Accepted | 39.25 | N, K, *A = list(map(int, open(0).read().split()))
neg = sorted([-a for a in A if a < 0])
pos = sorted([a for a in A if a >= 0])
def _count_pair_neg(x):
x = -x
res = 0
MAX = len(pos)
i = 0
for n in reversed(neg):
while i < MAX and n * pos[i] < x:
i += 1
res += MAX - i
return res
def _count_pair_pos(x):
res = 0
# Negative list
i = 0
MAX = len(neg)
for n in reversed(neg):
if n * n <= x:
res -= 1
while i < MAX and neg[i] * n <= x:
i += 1
res += i
# Positive list
i = 0
MAX = len(pos)
for n in reversed(pos):
if n * n <= x:
res -= 1
while i < MAX and pos[i] * n <= x:
i += 1
res += i
# Devide by 2 for counting the same pair twice
res //= 2
res += len(neg) * len(pos)
return res
def count_pair(x):
if x < 0:
return _count_pair_neg(x)
return _count_pair_pos(x)
# Bounds
lb = 0
ub = 2 * 10 ** 18 + 2
while ub - lb > 1:
mid = (ub + lb) // 2
if count_pair(mid - 10 ** 18 - 1) < K:
lb = mid
else:
ub = mid
print((ub - 10 ** 18 - 1))
| N, K, *A = list(map(int, open(0).read().split()))
l_pos = sorted(v for v in A if v > 0)
l_neg = sorted(-v for v in A if v < 0)
cnt_pos = len(l_pos)
cnt_neg = len(l_neg)
pair_pos = cnt_pos * (cnt_pos - 1) // 2 + cnt_neg * (cnt_neg - 1) // 2
pair_neg = cnt_pos * cnt_neg
pair_zro = N * (N - 1) // 2 - pair_pos - pair_neg
def solve_neg(n):
ub = 10 ** 18 + 1
lb = 0
while ub - lb > 1:
mid = (ub + lb) // 2
# Count
n_pos = len(l_pos)
cnt = 0
j = 0
for v in reversed(l_neg):
while j < n_pos and v * l_pos[j] < mid:
j += 1
cnt += n_pos - j
if cnt < n:
ub = mid
else:
lb = mid
return -lb
def solve_pos(n):
lb = 0
ub = 10 ** 18 + 1
while ub - lb > 1:
cnt = 0
mid = (ub + lb) // 2
# Negative count
n_neg = len(l_neg)
j = 0
for v in reversed(l_neg):
if v ** 2 <= mid:
cnt -= 1
while j < n_neg and v * l_neg[j] < mid:
j += 1
cnt += j
# Positive count
n_pos = len(l_pos)
j = 0
for v in reversed(l_pos):
if v ** 2 <= mid:
cnt -= 1
while j < n_pos and v * l_pos[j] < mid:
j += 1
cnt += j
# Remove duplicated counts
cnt //= 2
if cnt < n:
lb = mid
else:
ub = mid
return lb
if K <= pair_neg:
ans = solve_neg(K)
elif K <= pair_neg + pair_zro:
ans = 0
else:
ans = solve_pos(K - pair_neg - pair_zro)
print(ans)
| 69 | 81 | 1,305 | 1,745 | N, K, *A = list(map(int, open(0).read().split()))
neg = sorted([-a for a in A if a < 0])
pos = sorted([a for a in A if a >= 0])
def _count_pair_neg(x):
x = -x
res = 0
MAX = len(pos)
i = 0
for n in reversed(neg):
while i < MAX and n * pos[i] < x:
i += 1
res += MAX - i
return res
def _count_pair_pos(x):
res = 0
# Negative list
i = 0
MAX = len(neg)
for n in reversed(neg):
if n * n <= x:
res -= 1
while i < MAX and neg[i] * n <= x:
i += 1
res += i
# Positive list
i = 0
MAX = len(pos)
for n in reversed(pos):
if n * n <= x:
res -= 1
while i < MAX and pos[i] * n <= x:
i += 1
res += i
# Devide by 2 for counting the same pair twice
res //= 2
res += len(neg) * len(pos)
return res
def count_pair(x):
if x < 0:
return _count_pair_neg(x)
return _count_pair_pos(x)
# Bounds
lb = 0
ub = 2 * 10**18 + 2
while ub - lb > 1:
mid = (ub + lb) // 2
if count_pair(mid - 10**18 - 1) < K:
lb = mid
else:
ub = mid
print((ub - 10**18 - 1))
| N, K, *A = list(map(int, open(0).read().split()))
l_pos = sorted(v for v in A if v > 0)
l_neg = sorted(-v for v in A if v < 0)
cnt_pos = len(l_pos)
cnt_neg = len(l_neg)
pair_pos = cnt_pos * (cnt_pos - 1) // 2 + cnt_neg * (cnt_neg - 1) // 2
pair_neg = cnt_pos * cnt_neg
pair_zro = N * (N - 1) // 2 - pair_pos - pair_neg
def solve_neg(n):
ub = 10**18 + 1
lb = 0
while ub - lb > 1:
mid = (ub + lb) // 2
# Count
n_pos = len(l_pos)
cnt = 0
j = 0
for v in reversed(l_neg):
while j < n_pos and v * l_pos[j] < mid:
j += 1
cnt += n_pos - j
if cnt < n:
ub = mid
else:
lb = mid
return -lb
def solve_pos(n):
lb = 0
ub = 10**18 + 1
while ub - lb > 1:
cnt = 0
mid = (ub + lb) // 2
# Negative count
n_neg = len(l_neg)
j = 0
for v in reversed(l_neg):
if v**2 <= mid:
cnt -= 1
while j < n_neg and v * l_neg[j] < mid:
j += 1
cnt += j
# Positive count
n_pos = len(l_pos)
j = 0
for v in reversed(l_pos):
if v**2 <= mid:
cnt -= 1
while j < n_pos and v * l_pos[j] < mid:
j += 1
cnt += j
# Remove duplicated counts
cnt //= 2
if cnt < n:
lb = mid
else:
ub = mid
return lb
if K <= pair_neg:
ans = solve_neg(K)
elif K <= pair_neg + pair_zro:
ans = 0
else:
ans = solve_pos(K - pair_neg - pair_zro)
print(ans)
| false | 14.814815 | [
"-neg = sorted([-a for a in A if a < 0])",
"-pos = sorted([a for a in A if a >= 0])",
"+l_pos = sorted(v for v in A if v > 0)",
"+l_neg = sorted(-v for v in A if v < 0)",
"+cnt_pos = len(l_pos)",
"+cnt_neg = len(l_neg)",
"+pair_pos = cnt_pos * (cnt_pos - 1) // 2 + cnt_neg * (cnt_neg - 1) // 2",
"+pair_neg = cnt_pos * cnt_neg",
"+pair_zro = N * (N - 1) // 2 - pair_pos - pair_neg",
"-def _count_pair_neg(x):",
"- x = -x",
"- res = 0",
"- MAX = len(pos)",
"- i = 0",
"- for n in reversed(neg):",
"- while i < MAX and n * pos[i] < x:",
"- i += 1",
"- res += MAX - i",
"- return res",
"+def solve_neg(n):",
"+ ub = 10**18 + 1",
"+ lb = 0",
"+ while ub - lb > 1:",
"+ mid = (ub + lb) // 2",
"+ # Count",
"+ n_pos = len(l_pos)",
"+ cnt = 0",
"+ j = 0",
"+ for v in reversed(l_neg):",
"+ while j < n_pos and v * l_pos[j] < mid:",
"+ j += 1",
"+ cnt += n_pos - j",
"+ if cnt < n:",
"+ ub = mid",
"+ else:",
"+ lb = mid",
"+ return -lb",
"-def _count_pair_pos(x):",
"- res = 0",
"- # Negative list",
"- i = 0",
"- MAX = len(neg)",
"- for n in reversed(neg):",
"- if n * n <= x:",
"- res -= 1",
"- while i < MAX and neg[i] * n <= x:",
"- i += 1",
"- res += i",
"- # Positive list",
"- i = 0",
"- MAX = len(pos)",
"- for n in reversed(pos):",
"- if n * n <= x:",
"- res -= 1",
"- while i < MAX and pos[i] * n <= x:",
"- i += 1",
"- res += i",
"- # Devide by 2 for counting the same pair twice",
"- res //= 2",
"- res += len(neg) * len(pos)",
"- return res",
"+def solve_pos(n):",
"+ lb = 0",
"+ ub = 10**18 + 1",
"+ while ub - lb > 1:",
"+ cnt = 0",
"+ mid = (ub + lb) // 2",
"+ # Negative count",
"+ n_neg = len(l_neg)",
"+ j = 0",
"+ for v in reversed(l_neg):",
"+ if v**2 <= mid:",
"+ cnt -= 1",
"+ while j < n_neg and v * l_neg[j] < mid:",
"+ j += 1",
"+ cnt += j",
"+ # Positive count",
"+ n_pos = len(l_pos)",
"+ j = 0",
"+ for v in reversed(l_pos):",
"+ if v**2 <= mid:",
"+ cnt -= 1",
"+ while j < n_pos and v * l_pos[j] < mid:",
"+ j += 1",
"+ cnt += j",
"+ # Remove duplicated counts",
"+ cnt //= 2",
"+ if cnt < n:",
"+ lb = mid",
"+ else:",
"+ ub = mid",
"+ return lb",
"-def count_pair(x):",
"- if x < 0:",
"- return _count_pair_neg(x)",
"- return _count_pair_pos(x)",
"-",
"-",
"-# Bounds",
"-lb = 0",
"-ub = 2 * 10**18 + 2",
"-while ub - lb > 1:",
"- mid = (ub + lb) // 2",
"- if count_pair(mid - 10**18 - 1) < K:",
"- lb = mid",
"- else:",
"- ub = mid",
"-print((ub - 10**18 - 1))",
"+if K <= pair_neg:",
"+ ans = solve_neg(K)",
"+elif K <= pair_neg + pair_zro:",
"+ ans = 0",
"+else:",
"+ ans = solve_pos(K - pair_neg - pair_zro)",
"+print(ans)"
]
| false | 0.102908 | 0.047724 | 2.156299 | [
"s142154628",
"s667595274"
]
|
u898336293 | p03045 | python | s221416534 | s180118748 | 727 | 533 | 119,124 | 110,204 | Accepted | Accepted | 26.69 | import numpy as np
import sys
sys.setrecursionlimit(10**5+1)
input = sys.stdin.readline
def dfs(v,G,visit):
visit[v-1]=1
for next in G[v-1]:
if visit[next-1]:
continue
_ = dfs(next,G,visit)
N, M =list(map(int, input().split()))
G = [[] for _ in range(N)]
for i in range(M):
a,b ,_= list(map(int, input().split()))
G[a-1].append(b)
G[b-1].append(a)
count = 0
visit = np.array([0]*N)
for i in range(1,N+1):
if visit[i-1]:
continue
if G[i-1]:
_ = dfs(i,G,visit)
else:
visit[i-1] = 1
count += 1
print(count) | import sys
sys.setrecursionlimit(10**5+10)
input = sys.stdin.readline
def dfs(v,G,visit):
visit[v-1]=1
for next in G[v-1]:
if visit[next-1]:
continue
_ = dfs(next,G,visit)
N, M =list(map(int, input().split()))
G = [[] for _ in range(N)]
for i in range(M):
a,b ,_= list(map(int, input().split()))
G[a-1].append(b)
G[b-1].append(a)
count = 0
visit = [0]*N
for i in range(1,N+1):
if visit[i-1]:
continue
if G[i-1]:
_ = dfs(i,G,visit)
else:
visit[i-1] = 1
count += 1
print(count) | 32 | 30 | 613 | 585 | import numpy as np
import sys
sys.setrecursionlimit(10**5 + 1)
input = sys.stdin.readline
def dfs(v, G, visit):
visit[v - 1] = 1
for next in G[v - 1]:
if visit[next - 1]:
continue
_ = dfs(next, G, visit)
N, M = list(map(int, input().split()))
G = [[] for _ in range(N)]
for i in range(M):
a, b, _ = list(map(int, input().split()))
G[a - 1].append(b)
G[b - 1].append(a)
count = 0
visit = np.array([0] * N)
for i in range(1, N + 1):
if visit[i - 1]:
continue
if G[i - 1]:
_ = dfs(i, G, visit)
else:
visit[i - 1] = 1
count += 1
print(count)
| import sys
sys.setrecursionlimit(10**5 + 10)
input = sys.stdin.readline
def dfs(v, G, visit):
visit[v - 1] = 1
for next in G[v - 1]:
if visit[next - 1]:
continue
_ = dfs(next, G, visit)
N, M = list(map(int, input().split()))
G = [[] for _ in range(N)]
for i in range(M):
a, b, _ = list(map(int, input().split()))
G[a - 1].append(b)
G[b - 1].append(a)
count = 0
visit = [0] * N
for i in range(1, N + 1):
if visit[i - 1]:
continue
if G[i - 1]:
_ = dfs(i, G, visit)
else:
visit[i - 1] = 1
count += 1
print(count)
| false | 6.25 | [
"-import numpy as np",
"-sys.setrecursionlimit(10**5 + 1)",
"+sys.setrecursionlimit(10**5 + 10)",
"-visit = np.array([0] * N)",
"+visit = [0] * N"
]
| false | 0.227089 | 0.043741 | 5.191665 | [
"s221416534",
"s180118748"
]
|
u263830634 | p02744 | python | s322431328 | s061295782 | 532 | 204 | 25,420 | 22,872 | Accepted | Accepted | 61.65 | N = int(input())
lst = [['a']]
for i in range(N - 1):
n = len(lst)
tmp_lst = []
tmp_append = tmp_lst.append
for j in range(n):
tmp = lst[j]
count = len(set(tmp))
for k in range(count + 1):
tmp_append(tmp + [chr(k + 97)])
lst = tmp_lst
lst.sort()
for tmp in lst:
print (*tmp, sep = '')
| import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 9)
MOD = 10 ** 9 + 7
N = int(eval(input()))
lst1 = [('a', 0)]
lst2 = []
for i in range(N - 1):
if i % 2 == 0: #lst1 -->lst2
lst2 = []
for s, t in lst1:
last = max(ord(s[i]) - ord('a'), t)
for j in range(last + 2):
lst2.append((s + chr(j + ord('a')), max(t, j)))
else:
lst1 = []
for s, t in lst2:
last = max(ord(s[i]) - ord('a'), t)
for j in range(last + 2):
lst1.append((s + chr(j + ord('a')), (max(t, j))))
if len(lst2) > len(lst1):
lst2.sort()
for s, t in lst2:
print (s)
else:
lst1.sort()
for s, t in lst1:
print (s) | 17 | 31 | 362 | 775 | N = int(input())
lst = [["a"]]
for i in range(N - 1):
n = len(lst)
tmp_lst = []
tmp_append = tmp_lst.append
for j in range(n):
tmp = lst[j]
count = len(set(tmp))
for k in range(count + 1):
tmp_append(tmp + [chr(k + 97)])
lst = tmp_lst
lst.sort()
for tmp in lst:
print(*tmp, sep="")
| import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**9)
MOD = 10**9 + 7
N = int(eval(input()))
lst1 = [("a", 0)]
lst2 = []
for i in range(N - 1):
if i % 2 == 0: # lst1 -->lst2
lst2 = []
for s, t in lst1:
last = max(ord(s[i]) - ord("a"), t)
for j in range(last + 2):
lst2.append((s + chr(j + ord("a")), max(t, j)))
else:
lst1 = []
for s, t in lst2:
last = max(ord(s[i]) - ord("a"), t)
for j in range(last + 2):
lst1.append((s + chr(j + ord("a")), (max(t, j))))
if len(lst2) > len(lst1):
lst2.sort()
for s, t in lst2:
print(s)
else:
lst1.sort()
for s, t in lst1:
print(s)
| false | 45.16129 | [
"-N = int(input())",
"-lst = [[\"a\"]]",
"+import sys",
"+",
"+input = sys.stdin.readline",
"+sys.setrecursionlimit(10**9)",
"+MOD = 10**9 + 7",
"+N = int(eval(input()))",
"+lst1 = [(\"a\", 0)]",
"+lst2 = []",
"- n = len(lst)",
"- tmp_lst = []",
"- tmp_append = tmp_lst.append",
"- for j in range(n):",
"- tmp = lst[j]",
"- count = len(set(tmp))",
"- for k in range(count + 1):",
"- tmp_append(tmp + [chr(k + 97)])",
"- lst = tmp_lst",
"-lst.sort()",
"-for tmp in lst:",
"- print(*tmp, sep=\"\")",
"+ if i % 2 == 0: # lst1 -->lst2",
"+ lst2 = []",
"+ for s, t in lst1:",
"+ last = max(ord(s[i]) - ord(\"a\"), t)",
"+ for j in range(last + 2):",
"+ lst2.append((s + chr(j + ord(\"a\")), max(t, j)))",
"+ else:",
"+ lst1 = []",
"+ for s, t in lst2:",
"+ last = max(ord(s[i]) - ord(\"a\"), t)",
"+ for j in range(last + 2):",
"+ lst1.append((s + chr(j + ord(\"a\")), (max(t, j))))",
"+if len(lst2) > len(lst1):",
"+ lst2.sort()",
"+ for s, t in lst2:",
"+ print(s)",
"+else:",
"+ lst1.sort()",
"+ for s, t in lst1:",
"+ print(s)"
]
| false | 0.038677 | 0.042422 | 0.911716 | [
"s322431328",
"s061295782"
]
|
u062147869 | p04028 | python | s934821485 | s086861672 | 1,429 | 873 | 230,024 | 229,768 | Accepted | Accepted | 38.91 | N=int(eval(input()))
s=eval(input())
l=len(s)
dp=[[0]*(N+1) for i in range(N)]
dp[0][1]=2
dp[0][0]=1
mod=10**9+7
for i in range(N-1):
for j in range(N):
if j==0:
dp[i+1][j+1]+=2*dp[i][j]
dp[i+1][j+1]%=mod
dp[i+1][j]+=dp[i][j]
dp[i+1][j]%=mod
continue
if j!=N:
dp[i+1][j+1]+=2*dp[i][j]
dp[i+1][j+1]%=mod
dp[i+1][j-1]+=dp[i][j]
dp[i+1][j-1]%=mod
t=pow(2,(mod-2),mod)
t=pow(t,l,mod)
print(((dp[-1][l]*t)%mod)) | N=int(eval(input()))
s=eval(input())
l=len(s)
dp=[[0]*(N+2) for i in range(N)]
dp[0][1]=2
dp[0][0]=1
mod=10**9+7
for i in range(N-1):
for j in range(i+2):
if j==0:
dp[i+1][j+1]+=2*dp[i][j]
dp[i+1][j+1]%=mod
dp[i+1][j]+=dp[i][j]
dp[i+1][j]%=mod
continue
dp[i+1][j+1]+=2*dp[i][j]
dp[i+1][j+1]%=mod
dp[i+1][j-1]+=dp[i][j]
dp[i+1][j-1]%=mod
t=pow(2,(mod-2),mod)
t=pow(t,l,mod)
print(((dp[-1][l]*t)%mod)) | 23 | 22 | 548 | 524 | N = int(eval(input()))
s = eval(input())
l = len(s)
dp = [[0] * (N + 1) for i in range(N)]
dp[0][1] = 2
dp[0][0] = 1
mod = 10**9 + 7
for i in range(N - 1):
for j in range(N):
if j == 0:
dp[i + 1][j + 1] += 2 * dp[i][j]
dp[i + 1][j + 1] %= mod
dp[i + 1][j] += dp[i][j]
dp[i + 1][j] %= mod
continue
if j != N:
dp[i + 1][j + 1] += 2 * dp[i][j]
dp[i + 1][j + 1] %= mod
dp[i + 1][j - 1] += dp[i][j]
dp[i + 1][j - 1] %= mod
t = pow(2, (mod - 2), mod)
t = pow(t, l, mod)
print(((dp[-1][l] * t) % mod))
| N = int(eval(input()))
s = eval(input())
l = len(s)
dp = [[0] * (N + 2) for i in range(N)]
dp[0][1] = 2
dp[0][0] = 1
mod = 10**9 + 7
for i in range(N - 1):
for j in range(i + 2):
if j == 0:
dp[i + 1][j + 1] += 2 * dp[i][j]
dp[i + 1][j + 1] %= mod
dp[i + 1][j] += dp[i][j]
dp[i + 1][j] %= mod
continue
dp[i + 1][j + 1] += 2 * dp[i][j]
dp[i + 1][j + 1] %= mod
dp[i + 1][j - 1] += dp[i][j]
dp[i + 1][j - 1] %= mod
t = pow(2, (mod - 2), mod)
t = pow(t, l, mod)
print(((dp[-1][l] * t) % mod))
| false | 4.347826 | [
"-dp = [[0] * (N + 1) for i in range(N)]",
"+dp = [[0] * (N + 2) for i in range(N)]",
"- for j in range(N):",
"+ for j in range(i + 2):",
"- if j != N:",
"- dp[i + 1][j + 1] += 2 * dp[i][j]",
"- dp[i + 1][j + 1] %= mod",
"+ dp[i + 1][j + 1] += 2 * dp[i][j]",
"+ dp[i + 1][j + 1] %= mod"
]
| false | 0.047998 | 0.04946 | 0.970441 | [
"s934821485",
"s086861672"
]
|
u144913062 | p03240 | python | s326940504 | s676026066 | 199 | 98 | 41,072 | 73,900 | Accepted | Accepted | 50.75 | N = int(eval(input()))
xyh = [tuple(map(int, input().split())) for _ in range(N)]
xyh.sort(key=lambda a: -a[2])
for cx in range(101):
for cy in range(101):
x, y, h = xyh[0]
H = h+abs(cx-x)+abs(cy-y)
for i in range(1, N):
x, y, h = xyh[i]
if max(H-abs(cx-x)-abs(cy-y), 0) != h:
break
else:
print((cx, cy, H))
exit() | import sys
input = sys.stdin.readline
N = int(eval(input()))
x, y, h = list(zip(*[list(map(int, input().split())) for _ in range(N)]))
j = -1
for i in range(N):
if h[i] != 0:
j = i
break
for cx in range(101):
for cy in range(101):
H = h[j] + abs(x[j] - cx) + abs(y[j] - cy)
for i in range(N):
if h[i] != max(H - abs(x[i] - cx) - abs(y[i] - cy), 0):
break
else:
print((cx, cy, H))
| 14 | 19 | 419 | 474 | N = int(eval(input()))
xyh = [tuple(map(int, input().split())) for _ in range(N)]
xyh.sort(key=lambda a: -a[2])
for cx in range(101):
for cy in range(101):
x, y, h = xyh[0]
H = h + abs(cx - x) + abs(cy - y)
for i in range(1, N):
x, y, h = xyh[i]
if max(H - abs(cx - x) - abs(cy - y), 0) != h:
break
else:
print((cx, cy, H))
exit()
| import sys
input = sys.stdin.readline
N = int(eval(input()))
x, y, h = list(zip(*[list(map(int, input().split())) for _ in range(N)]))
j = -1
for i in range(N):
if h[i] != 0:
j = i
break
for cx in range(101):
for cy in range(101):
H = h[j] + abs(x[j] - cx) + abs(y[j] - cy)
for i in range(N):
if h[i] != max(H - abs(x[i] - cx) - abs(y[i] - cy), 0):
break
else:
print((cx, cy, H))
| false | 26.315789 | [
"+import sys",
"+",
"+input = sys.stdin.readline",
"-xyh = [tuple(map(int, input().split())) for _ in range(N)]",
"-xyh.sort(key=lambda a: -a[2])",
"+x, y, h = list(zip(*[list(map(int, input().split())) for _ in range(N)]))",
"+j = -1",
"+for i in range(N):",
"+ if h[i] != 0:",
"+ j = i",
"+ break",
"- x, y, h = xyh[0]",
"- H = h + abs(cx - x) + abs(cy - y)",
"- for i in range(1, N):",
"- x, y, h = xyh[i]",
"- if max(H - abs(cx - x) - abs(cy - y), 0) != h:",
"+ H = h[j] + abs(x[j] - cx) + abs(y[j] - cy)",
"+ for i in range(N):",
"+ if h[i] != max(H - abs(x[i] - cx) - abs(y[i] - cy), 0):",
"- exit()"
]
| false | 0.042305 | 0.062655 | 0.675213 | [
"s326940504",
"s676026066"
]
|
u347640436 | p02555 | python | s785207456 | s414891740 | 38 | 32 | 9,120 | 9,192 | Accepted | Accepted | 15.79 | def make_factorial_table(n):
result = [0] * (n + 1)
result[0] = 1
for i in range(1, n + 1):
result[i] = result[i - 1] * i % m
return result
def mcomb(n, k):
if n == 0 and k == 0:
return 1
if n < k or k < 0:
return 0
return fac[n] * pow(fac[n - k], m - 2, m) * pow(fac[k], m - 2, m) % m
m = 1000000007
S = int(eval(input()))
fac = make_factorial_table(S + 10)
if S < 2:
print((0))
exit()
result = 0
for i in range(1, 700):
t = S - i * 3
result += mcomb(t + i - 1, i - 1)
result %= m
print(result)
| def make_factorial_table(n):
result = [0] * (n + 1)
result[0] = 1
for i in range(1, n + 1):
result[i] = result[i - 1] * i % m
return result
def mcomb(n, k):
if n == 0 and k == 0:
return 1
if n < k or k < 0:
return 0
return fac[n] * pow(fac[n - k], m - 2, m) * pow(fac[k], m - 2, m) % m
m = 1000000007
S = int(eval(input()))
fac = make_factorial_table(S + 10)
result = 0
for i in range(1, S // 3 + 1):
result += mcomb(S - i * 3 + i - 1, i - 1)
result %= m
print(result)
| 32 | 27 | 599 | 556 | def make_factorial_table(n):
result = [0] * (n + 1)
result[0] = 1
for i in range(1, n + 1):
result[i] = result[i - 1] * i % m
return result
def mcomb(n, k):
if n == 0 and k == 0:
return 1
if n < k or k < 0:
return 0
return fac[n] * pow(fac[n - k], m - 2, m) * pow(fac[k], m - 2, m) % m
m = 1000000007
S = int(eval(input()))
fac = make_factorial_table(S + 10)
if S < 2:
print((0))
exit()
result = 0
for i in range(1, 700):
t = S - i * 3
result += mcomb(t + i - 1, i - 1)
result %= m
print(result)
| def make_factorial_table(n):
result = [0] * (n + 1)
result[0] = 1
for i in range(1, n + 1):
result[i] = result[i - 1] * i % m
return result
def mcomb(n, k):
if n == 0 and k == 0:
return 1
if n < k or k < 0:
return 0
return fac[n] * pow(fac[n - k], m - 2, m) * pow(fac[k], m - 2, m) % m
m = 1000000007
S = int(eval(input()))
fac = make_factorial_table(S + 10)
result = 0
for i in range(1, S // 3 + 1):
result += mcomb(S - i * 3 + i - 1, i - 1)
result %= m
print(result)
| false | 15.625 | [
"-if S < 2:",
"- print((0))",
"- exit()",
"-for i in range(1, 700):",
"- t = S - i * 3",
"- result += mcomb(t + i - 1, i - 1)",
"+for i in range(1, S // 3 + 1):",
"+ result += mcomb(S - i * 3 + i - 1, i - 1)"
]
| false | 0.039114 | 0.039539 | 0.989266 | [
"s785207456",
"s414891740"
]
|
u226155577 | p03083 | python | s229337428 | s633046753 | 592 | 402 | 65,912 | 70,876 | Accepted | Accepted | 32.09 | import sys
B, W = list(map(int, sys.stdin.readline().split()))
MOD = 10**9 + 7
L = B+W
fact = [1]*(L+1)
rfact = [1]*(L+1)
for i in range(L):
fact[i+1] = r = fact[i] * (i+1) % MOD
rfact[i+1] = pow(r, MOD-2, MOD)
rev2 = pow(2, MOD-2, MOD)
p = q = 0
base = 1
ans = ["%d\n" % rev2]
for i in range(1, B+W):
base = rev2 * base % MOD
if i-B >= 0:
p = (p + ((fact[i-1]*rfact[B-1] % MOD)*rfact[i-B] % MOD)*base % MOD) % MOD
if i-W >= 0:
q = (q + ((fact[i-1]*rfact[W-1] % MOD)*rfact[i-W] % MOD)*base % MOD) % MOD
ans.append("%d\n" % ((1-p+q)*rev2 % MOD))
sys.stdout.writelines(ans) | import __pypy__
import sys
B, W = list(map(int, sys.stdin.readline().split()))
MOD = 10**9 + 7
L = B+W
fact = [1]*(L+1)
rfact = [1]*(L+1)
for i in range(L):
fact[i+1] = r = fact[i] * (i+1) % MOD
rfact[i+1] = pow(r, MOD-2, MOD)
rev2 = pow(2, MOD-2, MOD)
p = q = 0
base = 1
bl = __pypy__.builders.StringBuilder(B+W)
bl.append("%d\n" % rev2)
for i in range(1, B+W):
base = rev2 * base % MOD
if i-B >= 0:
p = (p + ((fact[i-1]*rfact[B-1] % MOD)*rfact[i-B] % MOD)*base % MOD) % MOD
if i-W >= 0:
q = (q + ((fact[i-1]*rfact[W-1] % MOD)*rfact[i-W] % MOD)*base % MOD) % MOD
bl.append("%d\n" % ((1-p+q)*rev2 % MOD))
sys.stdout.write(bl.build()) | 25 | 27 | 633 | 697 | import sys
B, W = list(map(int, sys.stdin.readline().split()))
MOD = 10**9 + 7
L = B + W
fact = [1] * (L + 1)
rfact = [1] * (L + 1)
for i in range(L):
fact[i + 1] = r = fact[i] * (i + 1) % MOD
rfact[i + 1] = pow(r, MOD - 2, MOD)
rev2 = pow(2, MOD - 2, MOD)
p = q = 0
base = 1
ans = ["%d\n" % rev2]
for i in range(1, B + W):
base = rev2 * base % MOD
if i - B >= 0:
p = (
p + ((fact[i - 1] * rfact[B - 1] % MOD) * rfact[i - B] % MOD) * base % MOD
) % MOD
if i - W >= 0:
q = (
q + ((fact[i - 1] * rfact[W - 1] % MOD) * rfact[i - W] % MOD) * base % MOD
) % MOD
ans.append("%d\n" % ((1 - p + q) * rev2 % MOD))
sys.stdout.writelines(ans)
| import __pypy__
import sys
B, W = list(map(int, sys.stdin.readline().split()))
MOD = 10**9 + 7
L = B + W
fact = [1] * (L + 1)
rfact = [1] * (L + 1)
for i in range(L):
fact[i + 1] = r = fact[i] * (i + 1) % MOD
rfact[i + 1] = pow(r, MOD - 2, MOD)
rev2 = pow(2, MOD - 2, MOD)
p = q = 0
base = 1
bl = __pypy__.builders.StringBuilder(B + W)
bl.append("%d\n" % rev2)
for i in range(1, B + W):
base = rev2 * base % MOD
if i - B >= 0:
p = (
p + ((fact[i - 1] * rfact[B - 1] % MOD) * rfact[i - B] % MOD) * base % MOD
) % MOD
if i - W >= 0:
q = (
q + ((fact[i - 1] * rfact[W - 1] % MOD) * rfact[i - W] % MOD) * base % MOD
) % MOD
bl.append("%d\n" % ((1 - p + q) * rev2 % MOD))
sys.stdout.write(bl.build())
| false | 7.407407 | [
"+import __pypy__",
"-ans = [\"%d\\n\" % rev2]",
"+bl = __pypy__.builders.StringBuilder(B + W)",
"+bl.append(\"%d\\n\" % rev2)",
"- ans.append(\"%d\\n\" % ((1 - p + q) * rev2 % MOD))",
"-sys.stdout.writelines(ans)",
"+ bl.append(\"%d\\n\" % ((1 - p + q) * rev2 % MOD))",
"+sys.stdout.write(bl.build())"
]
| false | 0.099996 | 0.043968 | 2.274302 | [
"s229337428",
"s633046753"
]
|
u163320134 | p03038 | python | s634000410 | s523301018 | 670 | 501 | 33,732 | 37,572 | Accepted | Accepted | 25.22 | n,m=list(map(int,input().split()))
arr=list(map(int,input().split()))
arr=sorted(arr)
q=[list(map(int,input().split())) for _ in range(m)]
q=sorted(q,reverse=True,key=lambda x:x[0])
q=sorted(q,reverse=True,key=lambda x:x[1])
pos=0
for i in range(n):
if arr[i]<=q[pos][1]:
arr[i]=q[pos][1]
q[pos][0]-=1
if q[pos][0]==0:
pos+=1
if pos==m:
break
print((sum(arr))) | n,m=list(map(int,input().split()))
ans=list(map(int,input().split()))
arr=[list(map(int,input().split())) for _ in range(m)]
arr=sorted(arr,reverse=True,key=lambda x:x[1])
tmp=0
for cnt,val in arr:
ans+=[val]*cnt
tmp+=cnt
if tmp>=n:
break
ans=sorted(ans,reverse=True)
print((sum(ans[:n]))) | 16 | 12 | 401 | 302 | n, m = list(map(int, input().split()))
arr = list(map(int, input().split()))
arr = sorted(arr)
q = [list(map(int, input().split())) for _ in range(m)]
q = sorted(q, reverse=True, key=lambda x: x[0])
q = sorted(q, reverse=True, key=lambda x: x[1])
pos = 0
for i in range(n):
if arr[i] <= q[pos][1]:
arr[i] = q[pos][1]
q[pos][0] -= 1
if q[pos][0] == 0:
pos += 1
if pos == m:
break
print((sum(arr)))
| n, m = list(map(int, input().split()))
ans = list(map(int, input().split()))
arr = [list(map(int, input().split())) for _ in range(m)]
arr = sorted(arr, reverse=True, key=lambda x: x[1])
tmp = 0
for cnt, val in arr:
ans += [val] * cnt
tmp += cnt
if tmp >= n:
break
ans = sorted(ans, reverse=True)
print((sum(ans[:n])))
| false | 25 | [
"-arr = list(map(int, input().split()))",
"-arr = sorted(arr)",
"-q = [list(map(int, input().split())) for _ in range(m)]",
"-q = sorted(q, reverse=True, key=lambda x: x[0])",
"-q = sorted(q, reverse=True, key=lambda x: x[1])",
"-pos = 0",
"-for i in range(n):",
"- if arr[i] <= q[pos][1]:",
"- arr[i] = q[pos][1]",
"- q[pos][0] -= 1",
"- if q[pos][0] == 0:",
"- pos += 1",
"- if pos == m:",
"- break",
"-print((sum(arr)))",
"+ans = list(map(int, input().split()))",
"+arr = [list(map(int, input().split())) for _ in range(m)]",
"+arr = sorted(arr, reverse=True, key=lambda x: x[1])",
"+tmp = 0",
"+for cnt, val in arr:",
"+ ans += [val] * cnt",
"+ tmp += cnt",
"+ if tmp >= n:",
"+ break",
"+ans = sorted(ans, reverse=True)",
"+print((sum(ans[:n])))"
]
| false | 0.061833 | 0.047594 | 1.299179 | [
"s634000410",
"s523301018"
]
|
u425177436 | p03045 | python | s389827312 | s353742115 | 583 | 524 | 16,800 | 7,856 | Accepted | Accepted | 10.12 | class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n)]
self.rank = [0]*n
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.rank[x] < self.rank[y]:
self.par[x] = y
else:
self.par[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def same(self, x, y):
return self.find(x) == self.find(y)
n, m = list(map(int, input().split()))
uf = UnionFind(n)
for i in range(m):
x, y, z = list(map(int, input().split()))
uf.unite(x-1, y-1)
print((len(set(uf.find(i) for i in range(n))))) | class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n)]
self.rank = [0]*n
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.rank[x] < self.rank[y]:
self.par[x] = y
else:
self.par[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def same(self, x, y):
return self.find(x) == self.find(y)
n, m = list(map(int, input().split()))
uf = UnionFind(n)
for i in range(m):
x, y, z = list(map(int, input().split()))
uf.unite(x-1, y-1)
print((sum(uf.par[i] == i for i in range(n)))) | 33 | 33 | 866 | 865 | class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n)]
self.rank = [0] * n
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.rank[x] < self.rank[y]:
self.par[x] = y
else:
self.par[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def same(self, x, y):
return self.find(x) == self.find(y)
n, m = list(map(int, input().split()))
uf = UnionFind(n)
for i in range(m):
x, y, z = list(map(int, input().split()))
uf.unite(x - 1, y - 1)
print((len(set(uf.find(i) for i in range(n)))))
| class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n)]
self.rank = [0] * n
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.rank[x] < self.rank[y]:
self.par[x] = y
else:
self.par[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def same(self, x, y):
return self.find(x) == self.find(y)
n, m = list(map(int, input().split()))
uf = UnionFind(n)
for i in range(m):
x, y, z = list(map(int, input().split()))
uf.unite(x - 1, y - 1)
print((sum(uf.par[i] == i for i in range(n))))
| false | 0 | [
"-print((len(set(uf.find(i) for i in range(n)))))",
"+print((sum(uf.par[i] == i for i in range(n))))"
]
| false | 0.041859 | 0.108211 | 0.386825 | [
"s389827312",
"s353742115"
]
|
u784022244 | p03241 | python | s720117528 | s611900238 | 498 | 20 | 41,788 | 3,188 | Accepted | Accepted | 95.98 | N,M=list(map(int, input().split()))
if M%N==0:
print((M//N))
else:
a=M//N
while a>0:
if (M-a*N)%a==0:
print(a)
break
else:
a-=1 | N,M=list(map(int, input().split()))
#均等に配分したい
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
D=make_divisors(M)
D=sorted(D)
ans=0
for d in D:
if M//d>=N:
ans=d
print(ans)
| 12 | 20 | 163 | 391 | N, M = list(map(int, input().split()))
if M % N == 0:
print((M // N))
else:
a = M // N
while a > 0:
if (M - a * N) % a == 0:
print(a)
break
else:
a -= 1
| N, M = list(map(int, input().split()))
# 均等に配分したい
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
D = make_divisors(M)
D = sorted(D)
ans = 0
for d in D:
if M // d >= N:
ans = d
print(ans)
| false | 40 | [
"-if M % N == 0:",
"- print((M // N))",
"-else:",
"- a = M // N",
"- while a > 0:",
"- if (M - a * N) % a == 0:",
"- print(a)",
"- break",
"- else:",
"- a -= 1",
"+# 均等に配分したい",
"+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",
"+",
"+",
"+D = make_divisors(M)",
"+D = sorted(D)",
"+ans = 0",
"+for d in D:",
"+ if M // d >= N:",
"+ ans = d",
"+print(ans)"
]
| false | 0.120435 | 0.041145 | 2.927094 | [
"s720117528",
"s611900238"
]
|
u627803856 | p02614 | python | s694429165 | s998494181 | 200 | 124 | 73,916 | 72,852 | Accepted | Accepted | 38 | h, w, k = list(map(int, input().split()))
c = [[] for _ in range(h)]
numC, numR = [], []
for i in range(h):
c[i] = list(eval(input()))
from itertools import permutations, product
from copy import deepcopy
res = 0
for u in product([0, 1], repeat=h): # よこ
for v in product([0, 1], repeat=w): # たて
tmp = deepcopy(c)
for i in range(h):
if u[i] == 0:
for j in range(w):
if tmp[i][j] == '#':
tmp[i] = '.' * w
for i in range(w):
if v[i] == 0:
for j in range(h):
if tmp[j][i] == '#':
tmp[j][i] = '.'
# count
cnt = 0
for j in range(h):
for i in range(w):
if tmp[j][i] == '#':
cnt += 1
if cnt == k:
res += 1
print(res) | h, w, k = list(map(int, input().split()))
c = [[] for _ in range(h)]
for i in range(h):
c[i] = eval(input())
res = 0
from itertools import product
for v1 in product([0,1], repeat=h):
for v2 in product([0,1], repeat=w):
cnt = 0
for i in range(h):
if v1[i] == 0: continue
for j in range(w):
if v2[j] == 1 and c[i][j] == '#':
cnt += 1
if cnt == k:
res += 1
print(res) | 34 | 18 | 901 | 474 | h, w, k = list(map(int, input().split()))
c = [[] for _ in range(h)]
numC, numR = [], []
for i in range(h):
c[i] = list(eval(input()))
from itertools import permutations, product
from copy import deepcopy
res = 0
for u in product([0, 1], repeat=h): # よこ
for v in product([0, 1], repeat=w): # たて
tmp = deepcopy(c)
for i in range(h):
if u[i] == 0:
for j in range(w):
if tmp[i][j] == "#":
tmp[i] = "." * w
for i in range(w):
if v[i] == 0:
for j in range(h):
if tmp[j][i] == "#":
tmp[j][i] = "."
# count
cnt = 0
for j in range(h):
for i in range(w):
if tmp[j][i] == "#":
cnt += 1
if cnt == k:
res += 1
print(res)
| h, w, k = list(map(int, input().split()))
c = [[] for _ in range(h)]
for i in range(h):
c[i] = eval(input())
res = 0
from itertools import product
for v1 in product([0, 1], repeat=h):
for v2 in product([0, 1], repeat=w):
cnt = 0
for i in range(h):
if v1[i] == 0:
continue
for j in range(w):
if v2[j] == 1 and c[i][j] == "#":
cnt += 1
if cnt == k:
res += 1
print(res)
| false | 47.058824 | [
"-numC, numR = [], []",
"- c[i] = list(eval(input()))",
"-from itertools import permutations, product",
"-from copy import deepcopy",
"+ c[i] = eval(input())",
"+res = 0",
"+from itertools import product",
"-res = 0",
"-for u in product([0, 1], repeat=h): # よこ",
"- for v in product([0, 1], repeat=w): # たて",
"- tmp = deepcopy(c)",
"+for v1 in product([0, 1], repeat=h):",
"+ for v2 in product([0, 1], repeat=w):",
"+ cnt = 0",
"- if u[i] == 0:",
"- for j in range(w):",
"- if tmp[i][j] == \"#\":",
"- tmp[i] = \".\" * w",
"- for i in range(w):",
"- if v[i] == 0:",
"- for j in range(h):",
"- if tmp[j][i] == \"#\":",
"- tmp[j][i] = \".\"",
"- # count",
"- cnt = 0",
"- for j in range(h):",
"- for i in range(w):",
"- if tmp[j][i] == \"#\":",
"+ if v1[i] == 0:",
"+ continue",
"+ for j in range(w):",
"+ if v2[j] == 1 and c[i][j] == \"#\":"
]
| false | 0.089697 | 0.087891 | 1.020551 | [
"s694429165",
"s998494181"
]
|
u777923818 | p03613 | python | s168543224 | s553286514 | 240 | 214 | 16,292 | 16,308 | Accepted | Accepted | 10.83 | # -*- coding: utf-8 -*-
from collections import Counter
N = int(eval(input()))
A = tuple(map(int, input().split()))
c0 = Counter()
c1 = Counter()
c2 = Counter()
for a in A:
c0[(a+0)//3] += 1
c1[(a+1)//3] += 1
c2[(a+2)//3] += 1
print((max(sorted(list(c0.values()), reverse = True)[0],
sorted(list(c1.values()), reverse = True)[0],
sorted(list(c2.values()), reverse = True)[0])))
| # -*- coding: utf-8 -*-
from collections import Counter
N = int(eval(input()))
A = tuple(map(int, input().split()))
c0 = Counter()
c1 = Counter()
c2 = Counter()
for a in A:
c0[(a+0)//3] += 1
c1[(a+1)//3] += 1
c2[(a+2)//3] += 1
print((max(max(c0.values()),
max(c1.values()),
max(c2.values())))) | 16 | 16 | 407 | 339 | # -*- coding: utf-8 -*-
from collections import Counter
N = int(eval(input()))
A = tuple(map(int, input().split()))
c0 = Counter()
c1 = Counter()
c2 = Counter()
for a in A:
c0[(a + 0) // 3] += 1
c1[(a + 1) // 3] += 1
c2[(a + 2) // 3] += 1
print(
(
max(
sorted(list(c0.values()), reverse=True)[0],
sorted(list(c1.values()), reverse=True)[0],
sorted(list(c2.values()), reverse=True)[0],
)
)
)
| # -*- coding: utf-8 -*-
from collections import Counter
N = int(eval(input()))
A = tuple(map(int, input().split()))
c0 = Counter()
c1 = Counter()
c2 = Counter()
for a in A:
c0[(a + 0) // 3] += 1
c1[(a + 1) // 3] += 1
c2[(a + 2) // 3] += 1
print((max(max(c0.values()), max(c1.values()), max(c2.values()))))
| false | 0 | [
"-print(",
"- (",
"- max(",
"- sorted(list(c0.values()), reverse=True)[0],",
"- sorted(list(c1.values()), reverse=True)[0],",
"- sorted(list(c2.values()), reverse=True)[0],",
"- )",
"- )",
"-)",
"+print((max(max(c0.values()), max(c1.values()), max(c2.values()))))"
]
| false | 0.074826 | 0.03913 | 1.912247 | [
"s168543224",
"s553286514"
]
|
u644907318 | p02819 | python | s703715475 | s518454885 | 194 | 151 | 44,784 | 141,196 | Accepted | Accepted | 22.16 | from bisect import bisect_left
INFTY = 10**5+10
P = [1 for _ in range(INFTY)]
P[0]=0
P[1]=0
for i in range(2,int(INFTY**0.5)+1):
for j in range(i*i,INFTY,i):
P[j] = 0
Q = []
for i in range(INFTY):
if P[i]==1:
Q.append(i)
X = int(eval(input()))
ind = bisect_left(Q,X)
print((Q[ind])) | P = [1 for _ in range(10**6)]
P[0]=0
P[1]=0
for i in range(2,10**3+1):
for j in range(i*i,10**6,i):
P[j]=0
X = int(eval(input()))
for i in range(X,10**6):
if P[i]==1:
print(i)
break | 15 | 11 | 312 | 217 | from bisect import bisect_left
INFTY = 10**5 + 10
P = [1 for _ in range(INFTY)]
P[0] = 0
P[1] = 0
for i in range(2, int(INFTY**0.5) + 1):
for j in range(i * i, INFTY, i):
P[j] = 0
Q = []
for i in range(INFTY):
if P[i] == 1:
Q.append(i)
X = int(eval(input()))
ind = bisect_left(Q, X)
print((Q[ind]))
| P = [1 for _ in range(10**6)]
P[0] = 0
P[1] = 0
for i in range(2, 10**3 + 1):
for j in range(i * i, 10**6, i):
P[j] = 0
X = int(eval(input()))
for i in range(X, 10**6):
if P[i] == 1:
print(i)
break
| false | 26.666667 | [
"-from bisect import bisect_left",
"-",
"-INFTY = 10**5 + 10",
"-P = [1 for _ in range(INFTY)]",
"+P = [1 for _ in range(10**6)]",
"-for i in range(2, int(INFTY**0.5) + 1):",
"- for j in range(i * i, INFTY, i):",
"+for i in range(2, 10**3 + 1):",
"+ for j in range(i * i, 10**6, i):",
"-Q = []",
"-for i in range(INFTY):",
"+X = int(eval(input()))",
"+for i in range(X, 10**6):",
"- Q.append(i)",
"-X = int(eval(input()))",
"-ind = bisect_left(Q, X)",
"-print((Q[ind]))",
"+ print(i)",
"+ break"
]
| false | 0.10061 | 1.505419 | 0.066832 | [
"s703715475",
"s518454885"
]
|
u489959379 | p03274 | python | s192268629 | s073892784 | 102 | 85 | 14,532 | 19,832 | Accepted | Accepted | 16.67 | n, k = list(map(int, input().split()))
x = list(map(int, input().split()))
if x[0] >= 0:
print((x[k - 1]))
exit()
elif x[n - 1] < 0:
print((abs(x[n - k])))
exit()
else:
for i in range(n):
if x[i] >= 0:
ori = i
break
f_inf = float("inf")
res = f_inf
for i in range(max(ori - k, 0), min(ori + k, n) - k + 1):
time = min(abs(x[i + k - 1] - x[i]) + abs(x[i + k - 1]), abs(x[i]) + abs(x[i + k - 1] - x[i]))
res = min(res, time)
print(res)
| import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n, k = list(map(int, input().split()))
X = list(map(int, input().split()))
if X[0] >= 0:
print((X[k - 1]))
exit()
elif X[-1] < 0:
print((abs(X[n - k])))
exit()
else:
for i in range(n):
if X[i] >= 0:
ori = i
break
res = f_inf
left = max(ori - k, 0)
right = min(ori + k, n)
for i in range(left, right - k + 1):
RL = abs(X[i + k - 1] - X[i]) + abs(X[i + k - 1])
LR = abs(X[i]) + abs(X[i + k - 1] - X[i])
res = min(res, min(RL, LR))
print(res)
if __name__ == '__main__':
resolve()
| 22 | 36 | 508 | 784 | n, k = list(map(int, input().split()))
x = list(map(int, input().split()))
if x[0] >= 0:
print((x[k - 1]))
exit()
elif x[n - 1] < 0:
print((abs(x[n - k])))
exit()
else:
for i in range(n):
if x[i] >= 0:
ori = i
break
f_inf = float("inf")
res = f_inf
for i in range(max(ori - k, 0), min(ori + k, n) - k + 1):
time = min(
abs(x[i + k - 1] - x[i]) + abs(x[i + k - 1]),
abs(x[i]) + abs(x[i + k - 1] - x[i]),
)
res = min(res, time)
print(res)
| import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
f_inf = float("inf")
mod = 10**9 + 7
def resolve():
n, k = list(map(int, input().split()))
X = list(map(int, input().split()))
if X[0] >= 0:
print((X[k - 1]))
exit()
elif X[-1] < 0:
print((abs(X[n - k])))
exit()
else:
for i in range(n):
if X[i] >= 0:
ori = i
break
res = f_inf
left = max(ori - k, 0)
right = min(ori + k, n)
for i in range(left, right - k + 1):
RL = abs(X[i + k - 1] - X[i]) + abs(X[i + k - 1])
LR = abs(X[i]) + abs(X[i + k - 1] - X[i])
res = min(res, min(RL, LR))
print(res)
if __name__ == "__main__":
resolve()
| false | 38.888889 | [
"-n, k = list(map(int, input().split()))",
"-x = list(map(int, input().split()))",
"-if x[0] >= 0:",
"- print((x[k - 1]))",
"- exit()",
"-elif x[n - 1] < 0:",
"- print((abs(x[n - k])))",
"- exit()",
"-else:",
"- for i in range(n):",
"- if x[i] >= 0:",
"- ori = i",
"- break",
"+import sys",
"+",
"+sys.setrecursionlimit(10**7)",
"+input = sys.stdin.readline",
"-res = f_inf",
"-for i in range(max(ori - k, 0), min(ori + k, n) - k + 1):",
"- time = min(",
"- abs(x[i + k - 1] - x[i]) + abs(x[i + k - 1]),",
"- abs(x[i]) + abs(x[i + k - 1] - x[i]),",
"- )",
"- res = min(res, time)",
"-print(res)",
"+mod = 10**9 + 7",
"+",
"+",
"+def resolve():",
"+ n, k = list(map(int, input().split()))",
"+ X = list(map(int, input().split()))",
"+ if X[0] >= 0:",
"+ print((X[k - 1]))",
"+ exit()",
"+ elif X[-1] < 0:",
"+ print((abs(X[n - k])))",
"+ exit()",
"+ else:",
"+ for i in range(n):",
"+ if X[i] >= 0:",
"+ ori = i",
"+ break",
"+ res = f_inf",
"+ left = max(ori - k, 0)",
"+ right = min(ori + k, n)",
"+ for i in range(left, right - k + 1):",
"+ RL = abs(X[i + k - 1] - X[i]) + abs(X[i + k - 1])",
"+ LR = abs(X[i]) + abs(X[i + k - 1] - X[i])",
"+ res = min(res, min(RL, LR))",
"+ print(res)",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ resolve()"
]
| false | 0.087241 | 0.044433 | 1.963421 | [
"s192268629",
"s073892784"
]
|
u690536347 | p03425 | python | s416907040 | s807270094 | 179 | 149 | 3,064 | 9,404 | Accepted | Accepted | 16.76 | from itertools import combinations
N=int(eval(input()))
d={}
for _ in range(N):
s=eval(input())
if not s[0] in ["M","A","R","C","H"]:continue
if not s[0] in d:
d[s[0]]=1
else:
d[s[0]]+=1
res=0
for i in combinations(list(d.keys()),3):
res+=d[i[0]]*d[i[1]]*d[i[2]]
print(res) | from collections import Counter
from itertools import combinations as comb
N = int(eval(input()))
d = Counter()
for _ in range(N):
s = eval(input())
d[s[0]] += 1
ans = 0
for i, j, k in comb(["M","A","R","C","H"], 3):
ans += d[i]*d[j]*d[k]
print(ans)
| 14 | 13 | 287 | 264 | from itertools import combinations
N = int(eval(input()))
d = {}
for _ in range(N):
s = eval(input())
if not s[0] in ["M", "A", "R", "C", "H"]:
continue
if not s[0] in d:
d[s[0]] = 1
else:
d[s[0]] += 1
res = 0
for i in combinations(list(d.keys()), 3):
res += d[i[0]] * d[i[1]] * d[i[2]]
print(res)
| from collections import Counter
from itertools import combinations as comb
N = int(eval(input()))
d = Counter()
for _ in range(N):
s = eval(input())
d[s[0]] += 1
ans = 0
for i, j, k in comb(["M", "A", "R", "C", "H"], 3):
ans += d[i] * d[j] * d[k]
print(ans)
| false | 7.142857 | [
"-from itertools import combinations",
"+from collections import Counter",
"+from itertools import combinations as comb",
"-d = {}",
"+d = Counter()",
"- if not s[0] in [\"M\", \"A\", \"R\", \"C\", \"H\"]:",
"- continue",
"- if not s[0] in d:",
"- d[s[0]] = 1",
"- else:",
"- d[s[0]] += 1",
"-res = 0",
"-for i in combinations(list(d.keys()), 3):",
"- res += d[i[0]] * d[i[1]] * d[i[2]]",
"-print(res)",
"+ d[s[0]] += 1",
"+ans = 0",
"+for i, j, k in comb([\"M\", \"A\", \"R\", \"C\", \"H\"], 3):",
"+ ans += d[i] * d[j] * d[k]",
"+print(ans)"
]
| false | 0.036968 | 0.042015 | 0.87987 | [
"s416907040",
"s807270094"
]
|
u193264896 | p03681 | python | s938042901 | s789346727 | 61 | 43 | 11,052 | 6,900 | Accepted | Accepted | 29.51 | import sys
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 10 ** 9 + 7
def main():
N, M = list(map(int, input().split()))
mod = 10 ** 9 + 7
table = [1]
tmp = 1
for i in range(1, N + M + 1):
tmp *= i
tmp %= mod
table.append(tmp)
if abs(N - M) > 1:
print((0))
elif abs(N - M) == 1:
print((table[N] * table[M] % mod))
else:
print((2 * table[N] * table[M] % mod))
if __name__ == '__main__':
main()
| import sys
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 10 ** 9 + 7
def main():
N, M = list(map(int, readline().split()))
if abs(N-M)>1:
print('0')
elif N==M:
fact=[1]*(N+1)
for i in range(N):
fact[i+1] = fact[i]*(i+1)%MOD
ans = 2*fact[N]*fact[M]%MOD
print(ans)
else:
fact = [1] * (N + 3)
for i in range(N+2):
fact[i + 1] = fact[i] * (i + 1)%MOD
ans = fact[N] * fact[M]%MOD
print(ans)
if __name__ == '__main__':
main() | 28 | 24 | 544 | 600 | import sys
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10**8)
INF = float("inf")
MOD = 10**9 + 7
def main():
N, M = list(map(int, input().split()))
mod = 10**9 + 7
table = [1]
tmp = 1
for i in range(1, N + M + 1):
tmp *= i
tmp %= mod
table.append(tmp)
if abs(N - M) > 1:
print((0))
elif abs(N - M) == 1:
print((table[N] * table[M] % mod))
else:
print((2 * table[N] * table[M] % mod))
if __name__ == "__main__":
main()
| import sys
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10**8)
INF = float("inf")
MOD = 10**9 + 7
def main():
N, M = list(map(int, readline().split()))
if abs(N - M) > 1:
print("0")
elif N == M:
fact = [1] * (N + 1)
for i in range(N):
fact[i + 1] = fact[i] * (i + 1) % MOD
ans = 2 * fact[N] * fact[M] % MOD
print(ans)
else:
fact = [1] * (N + 3)
for i in range(N + 2):
fact[i + 1] = fact[i] * (i + 1) % MOD
ans = fact[N] * fact[M] % MOD
print(ans)
if __name__ == "__main__":
main()
| false | 14.285714 | [
"- N, M = list(map(int, input().split()))",
"- mod = 10**9 + 7",
"- table = [1]",
"- tmp = 1",
"- for i in range(1, N + M + 1):",
"- tmp *= i",
"- tmp %= mod",
"- table.append(tmp)",
"+ N, M = list(map(int, readline().split()))",
"- print((0))",
"- elif abs(N - M) == 1:",
"- print((table[N] * table[M] % mod))",
"+ print(\"0\")",
"+ elif N == M:",
"+ fact = [1] * (N + 1)",
"+ for i in range(N):",
"+ fact[i + 1] = fact[i] * (i + 1) % MOD",
"+ ans = 2 * fact[N] * fact[M] % MOD",
"+ print(ans)",
"- print((2 * table[N] * table[M] % mod))",
"+ fact = [1] * (N + 3)",
"+ for i in range(N + 2):",
"+ fact[i + 1] = fact[i] * (i + 1) % MOD",
"+ ans = fact[N] * fact[M] % MOD",
"+ print(ans)"
]
| false | 0.039982 | 0.081172 | 0.49256 | [
"s938042901",
"s789346727"
]
|
u816872429 | p03030 | python | s879349120 | s339313988 | 165 | 17 | 38,384 | 3,060 | Accepted | Accepted | 89.7 | n = int(eval(input()))
sp = [input().split() for _ in range(n)]
for i in sorted(list(range(n)), key=lambda i: (sp[i][0], -int(sp[i][1]))):
print((i + 1)) | n = int(eval(input()))
sp = [input().split() for _ in range(n)]
for (s, p), i in sorted(zip(sp, list(range(1, n + 1))), key=lambda x: (x[0][0], -int(x[0][1]))):
print(i) | 4 | 4 | 146 | 164 | n = int(eval(input()))
sp = [input().split() for _ in range(n)]
for i in sorted(list(range(n)), key=lambda i: (sp[i][0], -int(sp[i][1]))):
print((i + 1))
| n = int(eval(input()))
sp = [input().split() for _ in range(n)]
for (s, p), i in sorted(
zip(sp, list(range(1, n + 1))), key=lambda x: (x[0][0], -int(x[0][1]))
):
print(i)
| false | 0 | [
"-for i in sorted(list(range(n)), key=lambda i: (sp[i][0], -int(sp[i][1]))):",
"- print((i + 1))",
"+for (s, p), i in sorted(",
"+ zip(sp, list(range(1, n + 1))), key=lambda x: (x[0][0], -int(x[0][1]))",
"+):",
"+ print(i)"
]
| false | 0.045157 | 0.045679 | 0.988574 | [
"s879349120",
"s339313988"
]
|
u309977459 | p03212 | python | s291229509 | s025031600 | 153 | 60 | 7,348 | 3,064 | Accepted | Accepted | 60.78 | import sys
sys.setrecursionlimit(100000)
N = int(eval(input()))
svt = []
def dfs(num):
if num>1000000000:
return
#elif num<100:
# return
else:
svt.append(int(str(num)+'3'))
dfs(int(str(num)+'3'))
svt.append(int(str(num)+'5'))
dfs(int(str(num)+'5'))
svt.append(int(str(num)+'7'))
dfs(int(str(num)+'7'))
def check753(num):
exist3 = False
exist5 = False
exist7 = False
s = str(num)
for c in s:
if c=='3':
exist3 = True
elif c=='5':
exist5 = True
elif c=='7':
exist7 = True
if exist3 and exist5 and exist7:
return True
else:
return False
dfs(0)
svt = sorted(svt)
svt = svt[12:]
#print(svt)
count = 0
for i in range(len(svt)):
if svt[i]>N:
break
if check753(svt[i]):
count += 1
print(count)
| N = int(eval(input()))
cnt = 0
def dfs(n):
global cnt
if n>N:
return 0
s = str(n)
if '3' in s and '5' in s and '7' in s:
cnt += 1
dfs(int(s+'3'))
dfs(int(s+'5'))
dfs(int(s+'7'))
dfs(3)
dfs(5)
dfs(7)
print(cnt)
| 48 | 18 | 935 | 267 | import sys
sys.setrecursionlimit(100000)
N = int(eval(input()))
svt = []
def dfs(num):
if num > 1000000000:
return
# elif num<100:
# return
else:
svt.append(int(str(num) + "3"))
dfs(int(str(num) + "3"))
svt.append(int(str(num) + "5"))
dfs(int(str(num) + "5"))
svt.append(int(str(num) + "7"))
dfs(int(str(num) + "7"))
def check753(num):
exist3 = False
exist5 = False
exist7 = False
s = str(num)
for c in s:
if c == "3":
exist3 = True
elif c == "5":
exist5 = True
elif c == "7":
exist7 = True
if exist3 and exist5 and exist7:
return True
else:
return False
dfs(0)
svt = sorted(svt)
svt = svt[12:]
# print(svt)
count = 0
for i in range(len(svt)):
if svt[i] > N:
break
if check753(svt[i]):
count += 1
print(count)
| N = int(eval(input()))
cnt = 0
def dfs(n):
global cnt
if n > N:
return 0
s = str(n)
if "3" in s and "5" in s and "7" in s:
cnt += 1
dfs(int(s + "3"))
dfs(int(s + "5"))
dfs(int(s + "7"))
dfs(3)
dfs(5)
dfs(7)
print(cnt)
| false | 62.5 | [
"-import sys",
"-",
"-sys.setrecursionlimit(100000)",
"-svt = []",
"+cnt = 0",
"-def dfs(num):",
"- if num > 1000000000:",
"- return",
"- # elif num<100:",
"- # return",
"- else:",
"- svt.append(int(str(num) + \"3\"))",
"- dfs(int(str(num) + \"3\"))",
"- svt.append(int(str(num) + \"5\"))",
"- dfs(int(str(num) + \"5\"))",
"- svt.append(int(str(num) + \"7\"))",
"- dfs(int(str(num) + \"7\"))",
"+def dfs(n):",
"+ global cnt",
"+ if n > N:",
"+ return 0",
"+ s = str(n)",
"+ if \"3\" in s and \"5\" in s and \"7\" in s:",
"+ cnt += 1",
"+ dfs(int(s + \"3\"))",
"+ dfs(int(s + \"5\"))",
"+ dfs(int(s + \"7\"))",
"-def check753(num):",
"- exist3 = False",
"- exist5 = False",
"- exist7 = False",
"- s = str(num)",
"- for c in s:",
"- if c == \"3\":",
"- exist3 = True",
"- elif c == \"5\":",
"- exist5 = True",
"- elif c == \"7\":",
"- exist7 = True",
"- if exist3 and exist5 and exist7:",
"- return True",
"- else:",
"- return False",
"-",
"-",
"-dfs(0)",
"-svt = sorted(svt)",
"-svt = svt[12:]",
"-# print(svt)",
"-count = 0",
"-for i in range(len(svt)):",
"- if svt[i] > N:",
"- break",
"- if check753(svt[i]):",
"- count += 1",
"-print(count)",
"+dfs(3)",
"+dfs(5)",
"+dfs(7)",
"+print(cnt)"
]
| false | 0.007113 | 0.041904 | 0.169752 | [
"s291229509",
"s025031600"
]
|
u145231176 | p02781 | python | s055483888 | s399947427 | 212 | 194 | 78,584 | 84,248 | Accepted | Accepted | 8.49 | def getN():
return int(eval(input()))
def getNM():
return list(map(int, input().split()))
def getList():
return list(map(int, input().split()))
def getArray(intn):
return [int(eval(input())) for i in range(intn)]
def input():
return sys.stdin.readline().rstrip()
def rand_N(ran1, ran2):
return random.randint(ran1, ran2)
def rand_List(ran1, ran2, rantime):
return [random.randint(ran1, ran2) for i in range(rantime)]
def rand_ints_nodup(ran1, ran2, rantime):
ns = []
while len(ns) < rantime:
n = random.randint(ran1, ran2)
if not n in ns:
ns.append(n)
return sorted(ns)
def rand_query(ran1, ran2, rantime):
r_query = []
while len(r_query) < rantime:
n_q = rand_ints_nodup(ran1, ran2, 2)
if not n_q in r_query:
r_query.append(n_q)
return sorted(r_query)
from collections import defaultdict, deque, Counter
from sys import exit
from decimal import *
import heapq
import math
from fractions import gcd
import random
import string
import copy
from itertools import combinations, permutations, product
from operator import mul
from functools import reduce
from bisect import bisect_left, bisect_right
import sys
sys.setrecursionlimit(1000000000)
mod = 10 ** 9 + 7
#############
# Main Code #
#############
N = eval(input())
K = getN()
L = len(N)
def judge(a):
return a == 0
# N以下の数字で条件を満たす桁がk個のもの
def digit_dp(n, k):
l = len(n)
dp = [[[0] * (k + 1) for _ in range(2)] for i in range(l + 1)]
dp[0][0][0] = 1
for i in range(l):
d = int(n[i])
for j in range(2):
for d_j in range(10 if j else d + 1):
for k_j in range(k + 1):
# 0じゃない数字が混じっていれば数字は進む
if not judge(d_j):
# 求めたい個数以下なら
if k_j + 1 <= k:
dp[i + 1][j | (d_j < d)][k_j + 1] += dp[i][j][k_j]
else:
dp[i + 1][j | (d_j < d)][k_j] += dp[i][j][k_j]
return dp[l][0][k] + dp[l][1][k]
print((digit_dp(N, K))) | def getN():
return int(eval(input()))
def getNM():
return list(map(int, input().split()))
def getList():
return list(map(int, input().split()))
def getArray(intn):
return [int(eval(input())) for i in range(intn)]
def input():
return sys.stdin.readline().rstrip()
def rand_N(ran1, ran2):
return random.randint(ran1, ran2)
def rand_List(ran1, ran2, rantime):
return [random.randint(ran1, ran2) for i in range(rantime)]
def rand_ints_nodup(ran1, ran2, rantime):
ns = []
while len(ns) < rantime:
n = random.randint(ran1, ran2)
if not n in ns:
ns.append(n)
return sorted(ns)
def rand_query(ran1, ran2, rantime):
r_query = []
while len(r_query) < rantime:
n_q = rand_ints_nodup(ran1, ran2, 2)
if not n_q in r_query:
r_query.append(n_q)
return sorted(r_query)
from collections import defaultdict, deque, Counter
from sys import exit
from decimal import *
import heapq
import math
from fractions import gcd
import random
import string
import copy
from itertools import combinations, permutations, product
from operator import mul
from functools import reduce
from bisect import bisect_left, bisect_right
import sys
sys.setrecursionlimit(1000000000)
mod = 10 ** 9 + 7
#############
# Main Code #
#############
# ABC154 E - Almost Everywhere Zero
"""
N = '9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999'
K = 3
L = len(N)
"""
N = eval(input())
K = getN()
L = len(N)
def judge(a):
return a != 0
# N以下の数字で条件を満たす桁がk個のもの
def digit_dp(n, k):
l = len(n)
dp = [[[0] * (k + 1) for _ in range(2)] for i in range(l + 1)]
dp[0][0][0] = 1
for i in range(l):
d = int(n[i])
for j in range(2):
for d_j in range(10 if j else d + 1):
for k_j in range(k + 1):
if judge(d_j):
if k_j + 1 <= k:
dp[i + 1][j | (d_j < d)][k_j + 1] += dp[i][j][k_j]
else:
dp[i + 1][j | (d_j < d)][k_j] += dp[i][j][k_j]
return dp
dp = digit_dp(N, K)
print((dp[L][0][K] + dp[L][1][K]))
# ABC029 D - 1
"""
N = '999999999'
L = len(N)
def judge_2(a):
return a == 1
# N以下の数字の中で「1が書いてある桁がk個ある数字」がいくつあるか
# 上のものと関数の中身自体は変えていない
def digit_dp_2(n, k):
l = len(n)
dp = [[[0] * (k + 1) for _ in range(2)] for i in range(l + 1)]
dp[0][0][0] = 1
for i in range(l):
d = int(n[i])
for j in range(2):
for d_j in range(10 if j else d + 1):
for k_j in range(k + 1):
if judge_2(d_j):
if k_j + 1 <= k:
dp[i + 1][j | (d_j < d)][k_j + 1] += dp[i][j][k_j]
else:
dp[i + 1][j | (d_j < d)][k_j] += dp[i][j][k_j]
return dp
dp = digit_dp_2(N, L)
ans = 0
for j in range(L + 1):
# dp[l]について各j(1のカウント)の通りの数 * j
ans += (dp[L][0][j] + dp[L][1][j]) * j
print(ans)
""" | 84 | 129 | 2,115 | 3,101 | def getN():
return int(eval(input()))
def getNM():
return list(map(int, input().split()))
def getList():
return list(map(int, input().split()))
def getArray(intn):
return [int(eval(input())) for i in range(intn)]
def input():
return sys.stdin.readline().rstrip()
def rand_N(ran1, ran2):
return random.randint(ran1, ran2)
def rand_List(ran1, ran2, rantime):
return [random.randint(ran1, ran2) for i in range(rantime)]
def rand_ints_nodup(ran1, ran2, rantime):
ns = []
while len(ns) < rantime:
n = random.randint(ran1, ran2)
if not n in ns:
ns.append(n)
return sorted(ns)
def rand_query(ran1, ran2, rantime):
r_query = []
while len(r_query) < rantime:
n_q = rand_ints_nodup(ran1, ran2, 2)
if not n_q in r_query:
r_query.append(n_q)
return sorted(r_query)
from collections import defaultdict, deque, Counter
from sys import exit
from decimal import *
import heapq
import math
from fractions import gcd
import random
import string
import copy
from itertools import combinations, permutations, product
from operator import mul
from functools import reduce
from bisect import bisect_left, bisect_right
import sys
sys.setrecursionlimit(1000000000)
mod = 10**9 + 7
#############
# Main Code #
#############
N = eval(input())
K = getN()
L = len(N)
def judge(a):
return a == 0
# N以下の数字で条件を満たす桁がk個のもの
def digit_dp(n, k):
l = len(n)
dp = [[[0] * (k + 1) for _ in range(2)] for i in range(l + 1)]
dp[0][0][0] = 1
for i in range(l):
d = int(n[i])
for j in range(2):
for d_j in range(10 if j else d + 1):
for k_j in range(k + 1):
# 0じゃない数字が混じっていれば数字は進む
if not judge(d_j):
# 求めたい個数以下なら
if k_j + 1 <= k:
dp[i + 1][j | (d_j < d)][k_j + 1] += dp[i][j][k_j]
else:
dp[i + 1][j | (d_j < d)][k_j] += dp[i][j][k_j]
return dp[l][0][k] + dp[l][1][k]
print((digit_dp(N, K)))
| def getN():
return int(eval(input()))
def getNM():
return list(map(int, input().split()))
def getList():
return list(map(int, input().split()))
def getArray(intn):
return [int(eval(input())) for i in range(intn)]
def input():
return sys.stdin.readline().rstrip()
def rand_N(ran1, ran2):
return random.randint(ran1, ran2)
def rand_List(ran1, ran2, rantime):
return [random.randint(ran1, ran2) for i in range(rantime)]
def rand_ints_nodup(ran1, ran2, rantime):
ns = []
while len(ns) < rantime:
n = random.randint(ran1, ran2)
if not n in ns:
ns.append(n)
return sorted(ns)
def rand_query(ran1, ran2, rantime):
r_query = []
while len(r_query) < rantime:
n_q = rand_ints_nodup(ran1, ran2, 2)
if not n_q in r_query:
r_query.append(n_q)
return sorted(r_query)
from collections import defaultdict, deque, Counter
from sys import exit
from decimal import *
import heapq
import math
from fractions import gcd
import random
import string
import copy
from itertools import combinations, permutations, product
from operator import mul
from functools import reduce
from bisect import bisect_left, bisect_right
import sys
sys.setrecursionlimit(1000000000)
mod = 10**9 + 7
#############
# Main Code #
#############
# ABC154 E - Almost Everywhere Zero
"""
N = '9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999'
K = 3
L = len(N)
"""
N = eval(input())
K = getN()
L = len(N)
def judge(a):
return a != 0
# N以下の数字で条件を満たす桁がk個のもの
def digit_dp(n, k):
l = len(n)
dp = [[[0] * (k + 1) for _ in range(2)] for i in range(l + 1)]
dp[0][0][0] = 1
for i in range(l):
d = int(n[i])
for j in range(2):
for d_j in range(10 if j else d + 1):
for k_j in range(k + 1):
if judge(d_j):
if k_j + 1 <= k:
dp[i + 1][j | (d_j < d)][k_j + 1] += dp[i][j][k_j]
else:
dp[i + 1][j | (d_j < d)][k_j] += dp[i][j][k_j]
return dp
dp = digit_dp(N, K)
print((dp[L][0][K] + dp[L][1][K]))
# ABC029 D - 1
"""
N = '999999999'
L = len(N)
def judge_2(a):
return a == 1
# N以下の数字の中で「1が書いてある桁がk個ある数字」がいくつあるか
# 上のものと関数の中身自体は変えていない
def digit_dp_2(n, k):
l = len(n)
dp = [[[0] * (k + 1) for _ in range(2)] for i in range(l + 1)]
dp[0][0][0] = 1
for i in range(l):
d = int(n[i])
for j in range(2):
for d_j in range(10 if j else d + 1):
for k_j in range(k + 1):
if judge_2(d_j):
if k_j + 1 <= k:
dp[i + 1][j | (d_j < d)][k_j + 1] += dp[i][j][k_j]
else:
dp[i + 1][j | (d_j < d)][k_j] += dp[i][j][k_j]
return dp
dp = digit_dp_2(N, L)
ans = 0
for j in range(L + 1):
# dp[l]について各j(1のカウント)の通りの数 * j
ans += (dp[L][0][j] + dp[L][1][j]) * j
print(ans)
"""
| false | 34.883721 | [
"+# ABC154 E - Almost Everywhere Zero",
"+\"\"\"",
"+N = '9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999'",
"+K = 3",
"+L = len(N)",
"+\"\"\"",
"- return a == 0",
"+ return a != 0",
"- # 0じゃない数字が混じっていれば数字は進む",
"- if not judge(d_j):",
"- # 求めたい個数以下なら",
"+ if judge(d_j):",
"- return dp[l][0][k] + dp[l][1][k]",
"+ return dp",
"-print((digit_dp(N, K)))",
"+dp = digit_dp(N, K)",
"+print((dp[L][0][K] + dp[L][1][K]))",
"+# ABC029 D - 1",
"+\"\"\"",
"+N = '999999999'",
"+L = len(N)",
"+def judge_2(a):",
"+ return a == 1",
"+# N以下の数字の中で「1が書いてある桁がk個ある数字」がいくつあるか",
"+# 上のものと関数の中身自体は変えていない",
"+def digit_dp_2(n, k):",
"+ l = len(n)",
"+ dp = [[[0] * (k + 1) for _ in range(2)] for i in range(l + 1)]",
"+ dp[0][0][0] = 1",
"+ for i in range(l):",
"+ d = int(n[i])",
"+ for j in range(2):",
"+ for d_j in range(10 if j else d + 1):",
"+ for k_j in range(k + 1):",
"+ if judge_2(d_j):",
"+ if k_j + 1 <= k:",
"+ dp[i + 1][j | (d_j < d)][k_j + 1] += dp[i][j][k_j]",
"+ else:",
"+ dp[i + 1][j | (d_j < d)][k_j] += dp[i][j][k_j]",
"+ return dp",
"+dp = digit_dp_2(N, L)",
"+ans = 0",
"+for j in range(L + 1):",
"+ # dp[l]について各j(1のカウント)の通りの数 * j",
"+ ans += (dp[L][0][j] + dp[L][1][j]) * j",
"+print(ans)",
"+\"\"\""
]
| false | 0.087196 | 0.088094 | 0.989805 | [
"s055483888",
"s399947427"
]
|
u078042885 | p00060 | python | s807590934 | s051212928 | 30 | 20 | 7,656 | 7,656 | Accepted | Accepted | 33.33 | while 1:
a=[i+1 for i in range(10)]
try:b=list(map(int,input().split()))
except:break
for i in b:a.remove(i)
print((['NO','YES'][sum([1 for i in a if sum(b[:2],i)<=20])/7>=0.5])) | while 1:
a=[i+1 for i in range(10)]
try:b=list(map(int,input().split()))
except:break
for i in b:a.remove(i)
c=sum(b[:2])
print((['NO','YES'][sum([1 for i in a if c+i<=20])/7>=0.5])) | 6 | 7 | 201 | 210 | while 1:
a = [i + 1 for i in range(10)]
try:
b = list(map(int, input().split()))
except:
break
for i in b:
a.remove(i)
print((["NO", "YES"][sum([1 for i in a if sum(b[:2], i) <= 20]) / 7 >= 0.5]))
| while 1:
a = [i + 1 for i in range(10)]
try:
b = list(map(int, input().split()))
except:
break
for i in b:
a.remove(i)
c = sum(b[:2])
print((["NO", "YES"][sum([1 for i in a if c + i <= 20]) / 7 >= 0.5]))
| false | 14.285714 | [
"- print(([\"NO\", \"YES\"][sum([1 for i in a if sum(b[:2], i) <= 20]) / 7 >= 0.5]))",
"+ c = sum(b[:2])",
"+ print(([\"NO\", \"YES\"][sum([1 for i in a if c + i <= 20]) / 7 >= 0.5]))"
]
| false | 0.076064 | 0.075864 | 1.002645 | [
"s807590934",
"s051212928"
]
|
u238940874 | p02831 | python | s252608089 | s468529857 | 36 | 33 | 5,048 | 2,940 | Accepted | Accepted | 8.33 | from fractions import gcd
a,b=list(map(int,input().split()))
gcd=gcd(a,b)
ans=a*b//gcd
print(ans) | a,b=list(map(int,input().split()))
for i in range(1,10**5):
if a*i % b ==0:
print((a*i))
exit() | 5 | 5 | 95 | 111 | from fractions import gcd
a, b = list(map(int, input().split()))
gcd = gcd(a, b)
ans = a * b // gcd
print(ans)
| a, b = list(map(int, input().split()))
for i in range(1, 10**5):
if a * i % b == 0:
print((a * i))
exit()
| false | 0 | [
"-from fractions import gcd",
"-",
"-gcd = gcd(a, b)",
"-ans = a * b // gcd",
"-print(ans)",
"+for i in range(1, 10**5):",
"+ if a * i % b == 0:",
"+ print((a * i))",
"+ exit()"
]
| false | 0.142689 | 0.043353 | 3.291321 | [
"s252608089",
"s468529857"
]
|
u952708174 | p03575 | python | s490708796 | s397944082 | 26 | 24 | 3,064 | 3,064 | Accepted | Accepted | 7.69 | def c_bridge(N, M, E):
# N: 頂点の数, M: 辺の数, E: 辺で結ばれる頂点の組
def dfs(v):
is_visited[v] = True # 現在の頂点を訪問済にする
for v2 in range(N):
if not graph[v][v2] or is_visited[v2]:
continue # 頂点v2に行けないか、行く必要がない
dfs(v2)
graph = [[False for _ in range(N)] for _ in range(N)]
for a, b in E:
graph[a - 1][b - 1] = True
graph[b - 1][a - 1] = True
# 各辺は橋か？ グラフからその辺を取り除いて、グラフが連結かを判定
ans = 0
for a, b in E:
# 辺を取り除く
graph[a - 1][b - 1] = False
graph[b - 1][a - 1] = False
# すべての辺を未訪問として初期化
is_visited = [False for _ in range(N)]
# 頂点0からDFS
dfs(0)
# すべての頂点が訪問済なら連結、そうでなければ非連結
if not all(is_visited):
ans += 1
# 辺を復元
graph[a - 1][b - 1] = True
graph[b - 1][a - 1] = True
return ans
N,M = [int(i) for i in input().split()]
E = [[int(i) for i in input().split()] for j in range(M)]
print((c_bridge(N, M, E))) | def c_bridge(N, M, Edges):
def dfs(v):
is_visited[v] = True # 現在の頂点を訪問済にする
for v2 in range(N):
if not graph[v][v2] or is_visited[v2]:
continue # 頂点v2に行けないか、行く必要がない
dfs(v2)
graph = [[False for _ in range(N)] for _ in range(N)]
for a, b in Edges:
graph[a - 1][b - 1] = True
graph[b - 1][a - 1] = True
# 各辺は橋か？ グラフからその辺を取り除いて、グラフが連結かを判定
ans = 0
for a, b in Edges:
# 辺を取り除く
graph[a - 1][b - 1] = False
graph[b - 1][a - 1] = False
# すべての辺を未訪問として初期化
is_visited = [False for _ in range(N)]
# 全頂点に到達できなければ、除いた辺は橋である
dfs(0)
ans += 1 if not all(is_visited) else 0
# 辺を復元
graph[a - 1][b - 1] = True
graph[b - 1][a - 1] = True
return ans
N, M = [int(i) for i in input().split()]
Edges = [[int(i) for i in input().split()] for j in range(M)]
print((c_bridge(N, M, Edges))) | 37 | 34 | 1,032 | 985 | def c_bridge(N, M, E):
# N: 頂点の数, M: 辺の数, E: 辺で結ばれる頂点の組
def dfs(v):
is_visited[v] = True # 現在の頂点を訪問済にする
for v2 in range(N):
if not graph[v][v2] or is_visited[v2]:
continue # 頂点v2に行けないか、行く必要がない
dfs(v2)
graph = [[False for _ in range(N)] for _ in range(N)]
for a, b in E:
graph[a - 1][b - 1] = True
graph[b - 1][a - 1] = True
# 各辺は橋か？ グラフからその辺を取り除いて、グラフが連結かを判定
ans = 0
for a, b in E:
# 辺を取り除く
graph[a - 1][b - 1] = False
graph[b - 1][a - 1] = False
# すべての辺を未訪問として初期化
is_visited = [False for _ in range(N)]
# 頂点0からDFS
dfs(0)
# すべての頂点が訪問済なら連結、そうでなければ非連結
if not all(is_visited):
ans += 1
# 辺を復元
graph[a - 1][b - 1] = True
graph[b - 1][a - 1] = True
return ans
N, M = [int(i) for i in input().split()]
E = [[int(i) for i in input().split()] for j in range(M)]
print((c_bridge(N, M, E)))
| def c_bridge(N, M, Edges):
def dfs(v):
is_visited[v] = True # 現在の頂点を訪問済にする
for v2 in range(N):
if not graph[v][v2] or is_visited[v2]:
continue # 頂点v2に行けないか、行く必要がない
dfs(v2)
graph = [[False for _ in range(N)] for _ in range(N)]
for a, b in Edges:
graph[a - 1][b - 1] = True
graph[b - 1][a - 1] = True
# 各辺は橋か？ グラフからその辺を取り除いて、グラフが連結かを判定
ans = 0
for a, b in Edges:
# 辺を取り除く
graph[a - 1][b - 1] = False
graph[b - 1][a - 1] = False
# すべての辺を未訪問として初期化
is_visited = [False for _ in range(N)]
# 全頂点に到達できなければ、除いた辺は橋である
dfs(0)
ans += 1 if not all(is_visited) else 0
# 辺を復元
graph[a - 1][b - 1] = True
graph[b - 1][a - 1] = True
return ans
N, M = [int(i) for i in input().split()]
Edges = [[int(i) for i in input().split()] for j in range(M)]
print((c_bridge(N, M, Edges)))
| false | 8.108108 | [
"-def c_bridge(N, M, E):",
"- # N: 頂点の数, M: 辺の数, E: 辺で結ばれる頂点の組",
"+def c_bridge(N, M, Edges):",
"- for a, b in E:",
"+ for a, b in Edges:",
"- for a, b in E:",
"+ for a, b in Edges:",
"- # 頂点0からDFS",
"+ # 全頂点に到達できなければ、除いた辺は橋である",
"- # すべての頂点が訪問済なら連結、そうでなければ非連結",
"- if not all(is_visited):",
"- ans += 1",
"+ ans += 1 if not all(is_visited) else 0",
"-E = [[int(i) for i in input().split()] for j in range(M)]",
"-print((c_bridge(N, M, E)))",
"+Edges = [[int(i) for i in input().split()] for j in range(M)]",
"+print((c_bridge(N, M, Edges)))"
]
| false | 0.041366 | 0.1148 | 0.360331 | [
"s490708796",
"s397944082"
]
|
u254871849 | p03846 | python | s811930175 | s553288001 | 92 | 61 | 13,880 | 14,324 | Accepted | Accepted | 33.7 | mod = 10 ** 9 + 7
N = int(eval(input()))
A = [int(a) for a in input().split()]
A.sort()
if N % 2 != 0:
if A[0] == 0:
for i in range(2, N, 2):
if not (A[i] == i and A[i-1] == i):
print((0))
exit()
order_count = 2 ** ((N - 1) // 2) % mod
else:
print((0))
exit()
else:
for i in range(1, N, 2):
if not (A[i] == i and A[i-1] == i):
print((0))
exit()
order_count = 2 ** (N // 2) % mod
print(order_count) | import sys
from collections import Counter
MOD = 10 ** 9 + 7
n, *a = list(map(int, sys.stdin.read().split()))
def main():
c = Counter(a)
if n & 1:
if c.get(0, 0) != 1:
return 0
for i in range(2, n, 2):
if c.get(i, 0) != 2:
return 0
else:
for i in range(1, n, 2):
if c.get(i, 0) != 2:
return 0
return pow(2, n // 2, MOD)
if __name__ == '__main__':
ans = main()
print(ans) | 24 | 25 | 536 | 513 | mod = 10**9 + 7
N = int(eval(input()))
A = [int(a) for a in input().split()]
A.sort()
if N % 2 != 0:
if A[0] == 0:
for i in range(2, N, 2):
if not (A[i] == i and A[i - 1] == i):
print((0))
exit()
order_count = 2 ** ((N - 1) // 2) % mod
else:
print((0))
exit()
else:
for i in range(1, N, 2):
if not (A[i] == i and A[i - 1] == i):
print((0))
exit()
order_count = 2 ** (N // 2) % mod
print(order_count)
| import sys
from collections import Counter
MOD = 10**9 + 7
n, *a = list(map(int, sys.stdin.read().split()))
def main():
c = Counter(a)
if n & 1:
if c.get(0, 0) != 1:
return 0
for i in range(2, n, 2):
if c.get(i, 0) != 2:
return 0
else:
for i in range(1, n, 2):
if c.get(i, 0) != 2:
return 0
return pow(2, n // 2, MOD)
if __name__ == "__main__":
ans = main()
print(ans)
| false | 4 | [
"-mod = 10**9 + 7",
"-N = int(eval(input()))",
"-A = [int(a) for a in input().split()]",
"-A.sort()",
"-if N % 2 != 0:",
"- if A[0] == 0:",
"- for i in range(2, N, 2):",
"- if not (A[i] == i and A[i - 1] == i):",
"- print((0))",
"- exit()",
"- order_count = 2 ** ((N - 1) // 2) % mod",
"+import sys",
"+from collections import Counter",
"+",
"+MOD = 10**9 + 7",
"+n, *a = list(map(int, sys.stdin.read().split()))",
"+",
"+",
"+def main():",
"+ c = Counter(a)",
"+ if n & 1:",
"+ if c.get(0, 0) != 1:",
"+ return 0",
"+ for i in range(2, n, 2):",
"+ if c.get(i, 0) != 2:",
"+ return 0",
"- print((0))",
"- exit()",
"-else:",
"- for i in range(1, N, 2):",
"- if not (A[i] == i and A[i - 1] == i):",
"- print((0))",
"- exit()",
"- order_count = 2 ** (N // 2) % mod",
"-print(order_count)",
"+ for i in range(1, n, 2):",
"+ if c.get(i, 0) != 2:",
"+ return 0",
"+ return pow(2, n // 2, MOD)",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ ans = main()",
"+ print(ans)"
]
| false | 0.035863 | 0.039716 | 0.903 | [
"s811930175",
"s553288001"
]
|
u224353074 | p02744 | python | s230902787 | s302334269 | 184 | 152 | 4,340 | 4,412 | Accepted | Accepted | 17.39 | N = int(eval(input()))
def DFS(N, S):
if len(S) == N:
print(S)
else:
next_chrs = []
if S:
next_max_chr = ord(max(S)) + 1
else:
next_max_chr = ord("a")
for i in range(0, next_max_chr - ord("a") + 1):
DFS(N, "".join([S, chr(ord("a") + i)]))
DFS(N, "") | N = int(eval(input()))
def DFS(N, S):
if len(S) == N:
print(S)
else:
if S:
next_max_chr = ord(max(S)) + 1
else:
next_max_chr = ord("a")
for i in range(0, next_max_chr - ord("a") + 1):
DFS(N, S + chr(ord("a") + i))
DFS(N, "") | 17 | 16 | 347 | 313 | N = int(eval(input()))
def DFS(N, S):
if len(S) == N:
print(S)
else:
next_chrs = []
if S:
next_max_chr = ord(max(S)) + 1
else:
next_max_chr = ord("a")
for i in range(0, next_max_chr - ord("a") + 1):
DFS(N, "".join([S, chr(ord("a") + i)]))
DFS(N, "")
| N = int(eval(input()))
def DFS(N, S):
if len(S) == N:
print(S)
else:
if S:
next_max_chr = ord(max(S)) + 1
else:
next_max_chr = ord("a")
for i in range(0, next_max_chr - ord("a") + 1):
DFS(N, S + chr(ord("a") + i))
DFS(N, "")
| false | 5.882353 | [
"- next_chrs = []",
"- DFS(N, \"\".join([S, chr(ord(\"a\") + i)]))",
"+ DFS(N, S + chr(ord(\"a\") + i))"
]
| false | 0.051156 | 0.04979 | 1.027442 | [
"s230902787",
"s302334269"
]
|
u582577761 | p03724 | python | s916478914 | s922666597 | 635 | 547 | 50,648 | 45,400 | Accepted | Accepted | 13.86 | n,m=list(map(int,input().split()))
a=[0]*n
for i in range(m):
u,v=list(map(int,input().split()))
a[u-1]^=1
a[v-1]^=1
if sum(a):
print("NO")
else:
print("YES") | n,m=list(map(int,input().split()))
t=0
for i in range(m):
u,v=list(map(int,input().split()))
t^=u^v
print(("NO" if t else "YES")) | 10 | 6 | 160 | 122 | n, m = list(map(int, input().split()))
a = [0] * n
for i in range(m):
u, v = list(map(int, input().split()))
a[u - 1] ^= 1
a[v - 1] ^= 1
if sum(a):
print("NO")
else:
print("YES")
| n, m = list(map(int, input().split()))
t = 0
for i in range(m):
u, v = list(map(int, input().split()))
t ^= u ^ v
print(("NO" if t else "YES"))
| false | 40 | [
"-a = [0] * n",
"+t = 0",
"- a[u - 1] ^= 1",
"- a[v - 1] ^= 1",
"-if sum(a):",
"- print(\"NO\")",
"-else:",
"- print(\"YES\")",
"+ t ^= u ^ v",
"+print((\"NO\" if t else \"YES\"))"
]
| false | 0.037057 | 0.042481 | 0.872309 | [
"s916478914",
"s922666597"
]
|
u933341648 | p03244 | python | s751612822 | s461919045 | 109 | 92 | 22,752 | 20,692 | Accepted | Accepted | 15.6 | n = int(eval(input()))
v = list(map(int, input().split()))
a = {}
for i in range(0, len(v), 2):
a[v[i]] = a.get(v[i], 0) + 1
b = {}
for i in range(1, len(v), 2):
b[v[i]] = b.get(v[i], 0) + 1
sorted_a = sorted(list(a.items()), reverse=True, key=lambda x: x[1])
sorted_b = sorted(list(b.items()), reverse=True, key=lambda x: x[1])
res = 0
if sorted_a[0][0] == sorted_b[0][0]:
if sorted_a[0][1] > sorted_b[0][1]:
sorted_b[0], sorted_b[1] = sorted_b[1], sorted_b[0]
elif sorted_a[0][1] < sorted_b[0][1]:
sorted_a[0], sorted_a[1] = sorted_a[1], sorted_a[0]
else:
if len(sorted_b) == 1:
res += sorted_b[0][1]
elif sorted_a[1][1] > sorted_b[1][1]:
sorted_a[0], sorted_a[1] = sorted_a[1], sorted_a[0]
else:
sorted_b[0], sorted_b[1] = sorted_b[1], sorted_b[0]
res += len(v) - sorted_a[0][1] - sorted_b[0][1]
print(res) | from collections import Counter
n = int(eval(input()))
v = [int(x) for x in input().split()]
odd = sorted(list(Counter(v[0:n:2]).items()), reverse=True, key=lambda x: x[1])
even = sorted(list(Counter(v[1:n+1:2]).items()), reverse=True, key=lambda x: x[1])
if odd[0][0] != even[0][0]:
res = n - odd[0][1] - even[0][1]
elif len(odd) == 1:
res = odd[0][1]
else:
if odd[0][1] == even[0][1]:
if odd[1][1] >= even[1][1]:
res = n - odd[1][1] - even[0][1]
else:
res = n - odd[0][1] - even[1][1]
elif odd[0][1] > even[0][1]:
res = n - odd[0][1] - even[1][1]
else:
res = n - odd[1][1] - even[0][1]
print(res)
| 31 | 24 | 923 | 684 | n = int(eval(input()))
v = list(map(int, input().split()))
a = {}
for i in range(0, len(v), 2):
a[v[i]] = a.get(v[i], 0) + 1
b = {}
for i in range(1, len(v), 2):
b[v[i]] = b.get(v[i], 0) + 1
sorted_a = sorted(list(a.items()), reverse=True, key=lambda x: x[1])
sorted_b = sorted(list(b.items()), reverse=True, key=lambda x: x[1])
res = 0
if sorted_a[0][0] == sorted_b[0][0]:
if sorted_a[0][1] > sorted_b[0][1]:
sorted_b[0], sorted_b[1] = sorted_b[1], sorted_b[0]
elif sorted_a[0][1] < sorted_b[0][1]:
sorted_a[0], sorted_a[1] = sorted_a[1], sorted_a[0]
else:
if len(sorted_b) == 1:
res += sorted_b[0][1]
elif sorted_a[1][1] > sorted_b[1][1]:
sorted_a[0], sorted_a[1] = sorted_a[1], sorted_a[0]
else:
sorted_b[0], sorted_b[1] = sorted_b[1], sorted_b[0]
res += len(v) - sorted_a[0][1] - sorted_b[0][1]
print(res)
| from collections import Counter
n = int(eval(input()))
v = [int(x) for x in input().split()]
odd = sorted(list(Counter(v[0:n:2]).items()), reverse=True, key=lambda x: x[1])
even = sorted(list(Counter(v[1 : n + 1 : 2]).items()), reverse=True, key=lambda x: x[1])
if odd[0][0] != even[0][0]:
res = n - odd[0][1] - even[0][1]
elif len(odd) == 1:
res = odd[0][1]
else:
if odd[0][1] == even[0][1]:
if odd[1][1] >= even[1][1]:
res = n - odd[1][1] - even[0][1]
else:
res = n - odd[0][1] - even[1][1]
elif odd[0][1] > even[0][1]:
res = n - odd[0][1] - even[1][1]
else:
res = n - odd[1][1] - even[0][1]
print(res)
| false | 22.580645 | [
"+from collections import Counter",
"+",
"-v = list(map(int, input().split()))",
"-a = {}",
"-for i in range(0, len(v), 2):",
"- a[v[i]] = a.get(v[i], 0) + 1",
"-b = {}",
"-for i in range(1, len(v), 2):",
"- b[v[i]] = b.get(v[i], 0) + 1",
"-sorted_a = sorted(list(a.items()), reverse=True, key=lambda x: x[1])",
"-sorted_b = sorted(list(b.items()), reverse=True, key=lambda x: x[1])",
"-res = 0",
"-if sorted_a[0][0] == sorted_b[0][0]:",
"- if sorted_a[0][1] > sorted_b[0][1]:",
"- sorted_b[0], sorted_b[1] = sorted_b[1], sorted_b[0]",
"- elif sorted_a[0][1] < sorted_b[0][1]:",
"- sorted_a[0], sorted_a[1] = sorted_a[1], sorted_a[0]",
"+v = [int(x) for x in input().split()]",
"+odd = sorted(list(Counter(v[0:n:2]).items()), reverse=True, key=lambda x: x[1])",
"+even = sorted(list(Counter(v[1 : n + 1 : 2]).items()), reverse=True, key=lambda x: x[1])",
"+if odd[0][0] != even[0][0]:",
"+ res = n - odd[0][1] - even[0][1]",
"+elif len(odd) == 1:",
"+ res = odd[0][1]",
"+else:",
"+ if odd[0][1] == even[0][1]:",
"+ if odd[1][1] >= even[1][1]:",
"+ res = n - odd[1][1] - even[0][1]",
"+ else:",
"+ res = n - odd[0][1] - even[1][1]",
"+ elif odd[0][1] > even[0][1]:",
"+ res = n - odd[0][1] - even[1][1]",
"- if len(sorted_b) == 1:",
"- res += sorted_b[0][1]",
"- elif sorted_a[1][1] > sorted_b[1][1]:",
"- sorted_a[0], sorted_a[1] = sorted_a[1], sorted_a[0]",
"- else:",
"- sorted_b[0], sorted_b[1] = sorted_b[1], sorted_b[0]",
"-res += len(v) - sorted_a[0][1] - sorted_b[0][1]",
"+ res = n - odd[1][1] - even[0][1]"
]
| false | 0.045652 | 0.038013 | 1.200958 | [
"s751612822",
"s461919045"
]
|
u392319141 | p03640 | python | s282046717 | s208277169 | 265 | 27 | 47,080 | 3,828 | Accepted | Accepted | 89.81 | H , W = map(int,input().split())
N = int(input())
A = list(map(int,input().split()))
ans = [0] * (H * W)
index = 0
for color , a in enumerate(A) :
for _ in range(a) :
ans[index] = color + 1
index += 1
for i in range(H) :
sub = ans[i * W : (i + 1) * W]
if i % 2 == 0 :
for j in range(W) :
print('{} '.format(sub[j]), end='')
else :
sub.reverse()
for j in range(W) :
print('{} '.format(sub[j]), end='')
print('')
| H, W = list(map(int, input().split()))
N = int(eval(input()))
A = list(map(int, input().split()))
ans = []
for i, a in enumerate(A, start=1):
ans.extend([i] * a)
ans.sort()
for i, w in enumerate(range(0, H * W, W)):
print((*ans[w: w + W][::(-1)**i]))
| 24 | 11 | 523 | 257 | H, W = map(int, input().split())
N = int(input())
A = list(map(int, input().split()))
ans = [0] * (H * W)
index = 0
for color, a in enumerate(A):
for _ in range(a):
ans[index] = color + 1
index += 1
for i in range(H):
sub = ans[i * W : (i + 1) * W]
if i % 2 == 0:
for j in range(W):
print("{} ".format(sub[j]), end="")
else:
sub.reverse()
for j in range(W):
print("{} ".format(sub[j]), end="")
print("")
| H, W = list(map(int, input().split()))
N = int(eval(input()))
A = list(map(int, input().split()))
ans = []
for i, a in enumerate(A, start=1):
ans.extend([i] * a)
ans.sort()
for i, w in enumerate(range(0, H * W, W)):
print((*ans[w : w + W][:: (-1) ** i]))
| false | 54.166667 | [
"-H, W = map(int, input().split())",
"-N = int(input())",
"+H, W = list(map(int, input().split()))",
"+N = int(eval(input()))",
"-ans = [0] * (H * W)",
"-index = 0",
"-for color, a in enumerate(A):",
"- for _ in range(a):",
"- ans[index] = color + 1",
"- index += 1",
"-for i in range(H):",
"- sub = ans[i * W : (i + 1) * W]",
"- if i % 2 == 0:",
"- for j in range(W):",
"- print(\"{} \".format(sub[j]), end=\"\")",
"- else:",
"- sub.reverse()",
"- for j in range(W):",
"- print(\"{} \".format(sub[j]), end=\"\")",
"- print(\"\")",
"+ans = []",
"+for i, a in enumerate(A, start=1):",
"+ ans.extend([i] * a)",
"+ans.sort()",
"+for i, w in enumerate(range(0, H * W, W)):",
"+ print((*ans[w : w + W][:: (-1) ** i]))"
]
| false | 0.044309 | 0.043685 | 1.014281 | [
"s282046717",
"s208277169"
]
|
u492959898 | p02693 | python | s234048177 | s353341727 | 22 | 20 | 9,196 | 9,180 | Accepted | Accepted | 9.09 | K = int(eval(input()))
A, B = list(map(int, input().split()))
ps = int(A / K)
pa = A % K
qs = int(B / K)
qa = B % K
if A==B:
if pa==0:
print("OK")
else:
print("NG")
else:
if qs-ps>0:
print("OK")
else:
if pa==0 or qa ==0:
print("OK")
else:
print("NG") | import math
k=int(eval(input()))
a,b = list(map(int, input().split()))
ans="NG"
while a <= b:
if a%k==0:
ans ="OK"
a=b+1
else:
a=a+1
print(ans) | 22 | 13 | 282 | 153 | K = int(eval(input()))
A, B = list(map(int, input().split()))
ps = int(A / K)
pa = A % K
qs = int(B / K)
qa = B % K
if A == B:
if pa == 0:
print("OK")
else:
print("NG")
else:
if qs - ps > 0:
print("OK")
else:
if pa == 0 or qa == 0:
print("OK")
else:
print("NG")
| import math
k = int(eval(input()))
a, b = list(map(int, input().split()))
ans = "NG"
while a <= b:
if a % k == 0:
ans = "OK"
a = b + 1
else:
a = a + 1
print(ans)
| false | 40.909091 | [
"-K = int(eval(input()))",
"-A, B = list(map(int, input().split()))",
"-ps = int(A / K)",
"-pa = A % K",
"-qs = int(B / K)",
"-qa = B % K",
"-if A == B:",
"- if pa == 0:",
"- print(\"OK\")",
"+import math",
"+",
"+k = int(eval(input()))",
"+a, b = list(map(int, input().split()))",
"+ans = \"NG\"",
"+while a <= b:",
"+ if a % k == 0:",
"+ ans = \"OK\"",
"+ a = b + 1",
"- print(\"NG\")",
"-else:",
"- if qs - ps > 0:",
"- print(\"OK\")",
"- else:",
"- if pa == 0 or qa == 0:",
"- print(\"OK\")",
"- else:",
"- print(\"NG\")",
"+ a = a + 1",
"+print(ans)"
]
| false | 0.045243 | 0.045651 | 0.991062 | [
"s234048177",
"s353341727"
]
|
u588341295 | p02901 | python | s024230032 | s667476025 | 607 | 375 | 49,884 | 49,500 | Accepted | Accepted | 38.22 | # -*- coding: utf-8 -*-
import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7
N, M = MAP()
# (鍵の購入コスト, 開けられる宝箱)
keys = [None] * M
for i in range(M):
c, _ = MAP()
# どの宝箱を開けられるのかをbitで持っておく
s = 0
for a in [a-1 for a in LIST()]:
s += 1 << a
keys[i] = (c, s)
# dp[i][j] := i個目の鍵まで見て、集合jの宝箱を開けるための最小コスト
dp = list2d(2, 1<<N, INF)
dp[0][0] = 0
for i in range(M):
# 今回の鍵で開けられる宝箱の集合s
s = keys[i][1]
c = keys[i][0]
for j in range(1<<N):
# 今回の鍵を買わない遷移
dp[(i+1)%2][j] = min(dp[(i+1)%2][j], dp[i%2][j])
if dp[i%2][j] != INF:
m = j | s
# 買う遷移：遷移元の開けられる宝箱の集合j | 今回の鍵で開けられる宝箱の集合s
dp[(i+1)%2][m] = min(dp[(i+1)%2][m], dp[i%2][j]+c)
ans = dp[M%2][-1]
if ans != INF:
print(ans)
else:
print((-1))
| # -*- coding: utf-8 -*-
import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7
N, M = MAP()
# (鍵の購入コスト, 開けられる宝箱)
keys = [None] * M
for i in range(M):
c, _ = MAP()
# どの宝箱を開けられるのかをbitで持っておく
s = 0
for a in [a-1 for a in LIST()]:
s += 1 << a
keys[i] = (c, s)
# dp[i][j] := i個目の鍵まで見て、集合jの宝箱を開けるための最小コスト
dp = list2d(2, 1<<N, INF)
dp[0][0] = 0
for i in range(M):
# 今回の鍵で開けられる宝箱の集合s
s = keys[i][1]
c = keys[i][0]
cur = i % 2
nxt = (i+1) % 2
for j in range(1<<N):
# 今回の鍵を買わない遷移
dp[nxt][j] = min(dp[nxt][j], dp[cur][j])
if dp[cur][j] != INF:
m = j | s
# 買う遷移：遷移元の開けられる宝箱の集合j | 今回の鍵で開けられる宝箱の集合s
dp[nxt][m] = min(dp[nxt][m], dp[cur][j]+c)
ans = dp[M%2][-1]
if ans != INF:
print(ans)
else:
print((-1))
| 52 | 54 | 1,443 | 1,465 | # -*- coding: utf-8 -*-
import sys
def input():
return sys.stdin.readline().strip()
def list2d(a, b, c):
return [[c] * b for i in range(a)]
def list3d(a, b, c, d):
return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e):
return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1):
return int(-(-x // y))
def INT():
return int(eval(input()))
def MAP():
return list(map(int, input().split()))
def LIST(N=None):
return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes():
print("Yes")
def No():
print("No")
def YES():
print("YES")
def NO():
print("NO")
sys.setrecursionlimit(10**9)
INF = float("inf")
MOD = 10**9 + 7
N, M = MAP()
# (鍵の購入コスト, 開けられる宝箱)
keys = [None] * M
for i in range(M):
c, _ = MAP()
# どの宝箱を開けられるのかをbitで持っておく
s = 0
for a in [a - 1 for a in LIST()]:
s += 1 << a
keys[i] = (c, s)
# dp[i][j] := i個目の鍵まで見て、集合jの宝箱を開けるための最小コスト
dp = list2d(2, 1 << N, INF)
dp[0][0] = 0
for i in range(M):
# 今回の鍵で開けられる宝箱の集合s
s = keys[i][1]
c = keys[i][0]
for j in range(1 << N):
# 今回の鍵を買わない遷移
dp[(i + 1) % 2][j] = min(dp[(i + 1) % 2][j], dp[i % 2][j])
if dp[i % 2][j] != INF:
m = j | s
# 買う遷移：遷移元の開けられる宝箱の集合j | 今回の鍵で開けられる宝箱の集合s
dp[(i + 1) % 2][m] = min(dp[(i + 1) % 2][m], dp[i % 2][j] + c)
ans = dp[M % 2][-1]
if ans != INF:
print(ans)
else:
print((-1))
| # -*- coding: utf-8 -*-
import sys
def input():
return sys.stdin.readline().strip()
def list2d(a, b, c):
return [[c] * b for i in range(a)]
def list3d(a, b, c, d):
return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e):
return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1):
return int(-(-x // y))
def INT():
return int(eval(input()))
def MAP():
return list(map(int, input().split()))
def LIST(N=None):
return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes():
print("Yes")
def No():
print("No")
def YES():
print("YES")
def NO():
print("NO")
sys.setrecursionlimit(10**9)
INF = float("inf")
MOD = 10**9 + 7
N, M = MAP()
# (鍵の購入コスト, 開けられる宝箱)
keys = [None] * M
for i in range(M):
c, _ = MAP()
# どの宝箱を開けられるのかをbitで持っておく
s = 0
for a in [a - 1 for a in LIST()]:
s += 1 << a
keys[i] = (c, s)
# dp[i][j] := i個目の鍵まで見て、集合jの宝箱を開けるための最小コスト
dp = list2d(2, 1 << N, INF)
dp[0][0] = 0
for i in range(M):
# 今回の鍵で開けられる宝箱の集合s
s = keys[i][1]
c = keys[i][0]
cur = i % 2
nxt = (i + 1) % 2
for j in range(1 << N):
# 今回の鍵を買わない遷移
dp[nxt][j] = min(dp[nxt][j], dp[cur][j])
if dp[cur][j] != INF:
m = j | s
# 買う遷移：遷移元の開けられる宝箱の集合j | 今回の鍵で開けられる宝箱の集合s
dp[nxt][m] = min(dp[nxt][m], dp[cur][j] + c)
ans = dp[M % 2][-1]
if ans != INF:
print(ans)
else:
print((-1))
| false | 3.703704 | [
"+ cur = i % 2",
"+ nxt = (i + 1) % 2",
"- dp[(i + 1) % 2][j] = min(dp[(i + 1) % 2][j], dp[i % 2][j])",
"- if dp[i % 2][j] != INF:",
"+ dp[nxt][j] = min(dp[nxt][j], dp[cur][j])",
"+ if dp[cur][j] != INF:",
"- dp[(i + 1) % 2][m] = min(dp[(i + 1) % 2][m], dp[i % 2][j] + c)",
"+ dp[nxt][m] = min(dp[nxt][m], dp[cur][j] + c)"
]
| false | 0.036353 | 0.036863 | 0.986147 | [
"s024230032",
"s667476025"
]
|
u272963916 | p03013 | python | s165436931 | s698616728 | 518 | 400 | 462,708 | 460,056 | Accepted | Accepted | 22.78 | #-*- coding:utf-8 -*-
N, M = list(map(int, input().split()))
hsh = {}
for i in range(M):
hsh[int(eval(input()))] = True
acc = [0]*(N+1)
acc[0] = 1
for i in range(1,N+1):
d = 0
if i > 1 and i-2 not in hsh: # 2段前が穴ではない
if i-1 not in hsh: # 1段前が穴ではない
d += acc[i-1] + acc[i-2]
else:
d += acc[i-2]
else: # 2段前が穴
if i-1 not in hsh: # 1段前が穴ではない
d += acc[i-1]
else:
d = 0
acc[i] = d
# print(hsh)
# print(acc)
print((acc[-1]%1000000007))
| #-*- coding:utf-8 -*-
N, M = list(map(int, input().split()))
hsh = {}
for i in range(M):
hsh[int(eval(input()))] = True
acc = [0 for _ in range(N+1)]
acc[0] = 1
for i in range(1,N+1):
if i > 1 and i-2 in hsh: # 2段前が穴
if i-1 in hsh: # 1段前が穴
d = 0
else:
d = acc[i-1]
else: # 2段前が穴ではない
s = acc[i-2] if i > 1 else 0
if i-1 in hsh: # 1段前が穴
d = s
else:
d = acc[i-1] + s
acc[i] = d
# print(hsh)
# print(acc)
print((acc[-1]%1000000007))
| 27 | 27 | 549 | 553 | # -*- coding:utf-8 -*-
N, M = list(map(int, input().split()))
hsh = {}
for i in range(M):
hsh[int(eval(input()))] = True
acc = [0] * (N + 1)
acc[0] = 1
for i in range(1, N + 1):
d = 0
if i > 1 and i - 2 not in hsh: # 2段前が穴ではない
if i - 1 not in hsh: # 1段前が穴ではない
d += acc[i - 1] + acc[i - 2]
else:
d += acc[i - 2]
else: # 2段前が穴
if i - 1 not in hsh: # 1段前が穴ではない
d += acc[i - 1]
else:
d = 0
acc[i] = d
# print(hsh)
# print(acc)
print((acc[-1] % 1000000007))
| # -*- coding:utf-8 -*-
N, M = list(map(int, input().split()))
hsh = {}
for i in range(M):
hsh[int(eval(input()))] = True
acc = [0 for _ in range(N + 1)]
acc[0] = 1
for i in range(1, N + 1):
if i > 1 and i - 2 in hsh: # 2段前が穴
if i - 1 in hsh: # 1段前が穴
d = 0
else:
d = acc[i - 1]
else: # 2段前が穴ではない
s = acc[i - 2] if i > 1 else 0
if i - 1 in hsh: # 1段前が穴
d = s
else:
d = acc[i - 1] + s
acc[i] = d
# print(hsh)
# print(acc)
print((acc[-1] % 1000000007))
| false | 0 | [
"-acc = [0] * (N + 1)",
"+acc = [0 for _ in range(N + 1)]",
"- d = 0",
"- if i > 1 and i - 2 not in hsh: # 2段前が穴ではない",
"- if i - 1 not in hsh: # 1段前が穴ではない",
"- d += acc[i - 1] + acc[i - 2]",
"+ if i > 1 and i - 2 in hsh: # 2段前が穴",
"+ if i - 1 in hsh: # 1段前が穴",
"+ d = 0",
"- d += acc[i - 2]",
"- else: # 2段前が穴",
"- if i - 1 not in hsh: # 1段前が穴ではない",
"- d += acc[i - 1]",
"+ d = acc[i - 1]",
"+ else: # 2段前が穴ではない",
"+ s = acc[i - 2] if i > 1 else 0",
"+ if i - 1 in hsh: # 1段前が穴",
"+ d = s",
"- d = 0",
"+ d = acc[i - 1] + s"
]
| false | 0.085522 | 0.036225 | 2.360857 | [
"s165436931",
"s698616728"
]
|
u946263060 | p00761 | python | s104018993 | s747616673 | 50 | 40 | 5,628 | 5,624 | Accepted | Accepted | 20 | def is_unique2(seq):
seen = []
unique_list = [x for x in seq if x not in seen and not seen.append(x)]
return len(seq) == len(unique_list)
while True:
iCount = 0
n = input().split()
if int(n[1]) == 0:
break
num = n.pop(0)
m = int(n[0])
numStr = list(num)
while len(numStr) < m:
numStr.insert(0, "0")
numSub = [int(numStr[l]) for l in range(m)]
num0 = "".join([str(k) for k in numSub])
count = []
count.append(num0)
answer = "False"
while answer:
numSub.sort()
#print(numSub)
Min = "".join([str(j) for j in numSub])
numSub.reverse()
#print(numSub)
Max = "".join([str(i) for i in numSub])
num1 = int(Max) - int(Min)
num1 = str(num1)
xxx = list(num1)
while len(xxx) < m:
xxx.insert(0, "0")
numSub = [int(xxx[g]) for g in range(m)]
xxxx = "".join([str(h) for h in xxx])
count.append(str(xxxx))
answer = is_unique2(count)
iCount += 1
print(count.index(count[-1]) ,end=" ")
print(int(count[-1]) ,end=" ")
print(str(iCount - count.index(count[-1])))
| def is_unique2(seq):#後のwhile文でのループ脱出のため
seen = []
unique_list = [x for x in seq if x not in seen and not seen.append(x)]
return len(seq) == len(unique_list)
while True:
iCount = 0#問のiの部分の値です
n = input().split()
if int(n[1]) == 0:#入力の終わりを受けとった時breakする
break
a0 = n.pop(0)#a0は問のa0の値を受け取ってます
L = int(n[0])#Lは問のLの値を受け取ってます
numStr = list(a0)#a0を一文字ずつ分けてnumStrのリストに入れてます
while len(numStr) < L:#桁数が足りないとき、一番大きな位に０を入れてます
numStr.insert(0, "0")
numInt = [int(numStr[l]) for l in range(L)]#strからintへ型を変えてnumStrをnumIntに入れてます
A0 = "".join([str(k) for k in numInt])#numIntのリストの一文字ずつの数字を全部繋げてstr型としてA0に入れます(数値的にはa0と同値です)
count = []#a0,a1,a2,a3...ai(i < 20)の値を入れるcountリストを作ります
count.append(A0)#そのcountリストの中にまずA0を入れます
answer = "False"
while answer:#answerがTrueを受け取ったときこのループを抜けます
numInt.sort()#numIntのリストの中の数字が昇順に並び替えられます
Min = "".join([str(j) for j in numInt])#numIntのリストの一文字ずつの数字を全部繋げてstr型としてMinに入れます(数値的には並び替えてできる最小の整数)
numInt.reverse()#numIntのリストの中の数字が降順に並び替えられます
Max = "".join([str(i) for i in numInt])#numIntのリストの一文字ずつの数字を全部繋げてstr型としてMaxに入れます(数値的には並び替えてできる最大の整数)
ax = str(int(Max) - int(Min))#MaxからMinを引いてAx(x=1~20)の値をstr型でaxに入れます
numStr = list(ax)#axを一文字ずつ分けてnumStrのリストに入れてます(numStrではなく別の関数でも良いが、解りやすい為numStrに入れてます)
while len(numStr) < L:#桁数が足りないとき、一番大きな位に０を入れてます
numStr.insert(0, "0")
numInt = [int(numStr[g]) for g in range(L)]#strからintへ型を変えてnumStrをnumIntに入れてます(whileのループ処理のためnumIntに入れてます)
Ax = "".join([str(h) for h in numInt])#numIntのリストの一文字ずつの数字を全部繋げてstr型としてAx(x=1~20)に入れます(数値的にはax(x=1~20)と同値です)
count.append(str(Ax))#a0,a1,a2...aiの値を入れるcountリストの中にAxを入れます
answer = is_unique2(count)#countリスト内に同じ値が二つあるとき、answerはTrueを受け取り、while文のループから抜け出します
iCount += 1#今Ax番目の計算を行ったことを示し、answerがTrueを受け取った際は、それがAi番目となる
print(count.index(count[-1]) ,end=" ")#Ajのjの値を出力(スペース開けて改行しない)
print(int(count[-1]) ,end=" ")#Aiの値を出力(スペース開けて改行しない)
print(str(iCount - count.index(count[-1])))#Aiのi-Ajのjの値を出力
| 39 | 36 | 1,204 | 2,105 | def is_unique2(seq):
seen = []
unique_list = [x for x in seq if x not in seen and not seen.append(x)]
return len(seq) == len(unique_list)
while True:
iCount = 0
n = input().split()
if int(n[1]) == 0:
break
num = n.pop(0)
m = int(n[0])
numStr = list(num)
while len(numStr) < m:
numStr.insert(0, "0")
numSub = [int(numStr[l]) for l in range(m)]
num0 = "".join([str(k) for k in numSub])
count = []
count.append(num0)
answer = "False"
while answer:
numSub.sort()
# print(numSub)
Min = "".join([str(j) for j in numSub])
numSub.reverse()
# print(numSub)
Max = "".join([str(i) for i in numSub])
num1 = int(Max) - int(Min)
num1 = str(num1)
xxx = list(num1)
while len(xxx) < m:
xxx.insert(0, "0")
numSub = [int(xxx[g]) for g in range(m)]
xxxx = "".join([str(h) for h in xxx])
count.append(str(xxxx))
answer = is_unique2(count)
iCount += 1
print(count.index(count[-1]), end=" ")
print(int(count[-1]), end=" ")
print(str(iCount - count.index(count[-1])))
| def is_unique2(seq): # 後のwhile文でのループ脱出のため
seen = []
unique_list = [x for x in seq if x not in seen and not seen.append(x)]
return len(seq) == len(unique_list)
while True:
iCount = 0 # 問のiの部分の値です
n = input().split()
if int(n[1]) == 0: # 入力の終わりを受けとった時breakする
break
a0 = n.pop(0) # a0は問のa0の値を受け取ってます
L = int(n[0]) # Lは問のLの値を受け取ってます
numStr = list(a0) # a0を一文字ずつ分けてnumStrのリストに入れてます
while len(numStr) < L: # 桁数が足りないとき、一番大きな位に０を入れてます
numStr.insert(0, "0")
numInt = [int(numStr[l]) for l in range(L)] # strからintへ型を変えてnumStrをnumIntに入れてます
A0 = "".join(
[str(k) for k in numInt]
) # numIntのリストの一文字ずつの数字を全部繋げてstr型としてA0に入れます(数値的にはa0と同値です)
count = [] # a0,a1,a2,a3...ai(i < 20)の値を入れるcountリストを作ります
count.append(A0) # そのcountリストの中にまずA0を入れます
answer = "False"
while answer: # answerがTrueを受け取ったときこのループを抜けます
numInt.sort() # numIntのリストの中の数字が昇順に並び替えられます
Min = "".join(
[str(j) for j in numInt]
) # numIntのリストの一文字ずつの数字を全部繋げてstr型としてMinに入れます(数値的には並び替えてできる最小の整数)
numInt.reverse() # numIntのリストの中の数字が降順に並び替えられます
Max = "".join(
[str(i) for i in numInt]
) # numIntのリストの一文字ずつの数字を全部繋げてstr型としてMaxに入れます(数値的には並び替えてできる最大の整数)
ax = str(int(Max) - int(Min)) # MaxからMinを引いてAx(x=1~20)の値をstr型でaxに入れます
numStr = list(
ax
) # axを一文字ずつ分けてnumStrのリストに入れてます(numStrではなく別の関数でも良いが、解りやすい為numStrに入れてます)
while len(numStr) < L: # 桁数が足りないとき、一番大きな位に０を入れてます
numStr.insert(0, "0")
numInt = [
int(numStr[g]) for g in range(L)
] # strからintへ型を変えてnumStrをnumIntに入れてます(whileのループ処理のためnumIntに入れてます)
Ax = "".join(
[str(h) for h in numInt]
) # numIntのリストの一文字ずつの数字を全部繋げてstr型としてAx(x=1~20)に入れます(数値的にはax(x=1~20)と同値です)
count.append(str(Ax)) # a0,a1,a2...aiの値を入れるcountリストの中にAxを入れます
answer = is_unique2(
count
) # countリスト内に同じ値が二つあるとき、answerはTrueを受け取り、while文のループから抜け出します
iCount += 1 # 今Ax番目の計算を行ったことを示し、answerがTrueを受け取った際は、それがAi番目となる
print(count.index(count[-1]), end=" ") # Ajのjの値を出力(スペース開けて改行しない)
print(int(count[-1]), end=" ") # Aiの値を出力(スペース開けて改行しない)
print(str(iCount - count.index(count[-1]))) # Aiのi-Ajのjの値を出力
| false | 7.692308 | [
"-def is_unique2(seq):",
"+def is_unique2(seq): # 後のwhile文でのループ脱出のため",
"- iCount = 0",
"+ iCount = 0 # 問のiの部分の値です",
"- if int(n[1]) == 0:",
"+ if int(n[1]) == 0: # 入力の終わりを受けとった時breakする",
"- num = n.pop(0)",
"- m = int(n[0])",
"- numStr = list(num)",
"- while len(numStr) < m:",
"+ a0 = n.pop(0) # a0は問のa0の値を受け取ってます",
"+ L = int(n[0]) # Lは問のLの値を受け取ってます",
"+ numStr = list(a0) # a0を一文字ずつ分けてnumStrのリストに入れてます",
"+ while len(numStr) < L: # 桁数が足りないとき、一番大きな位に０を入れてます",
"- numSub = [int(numStr[l]) for l in range(m)]",
"- num0 = \"\".join([str(k) for k in numSub])",
"- count = []",
"- count.append(num0)",
"+ numInt = [int(numStr[l]) for l in range(L)] # strからintへ型を変えてnumStrをnumIntに入れてます",
"+ A0 = \"\".join(",
"+ [str(k) for k in numInt]",
"+ ) # numIntのリストの一文字ずつの数字を全部繋げてstr型としてA0に入れます(数値的にはa0と同値です)",
"+ count = [] # a0,a1,a2,a3...ai(i < 20)の値を入れるcountリストを作ります",
"+ count.append(A0) # そのcountリストの中にまずA0を入れます",
"- while answer:",
"- numSub.sort()",
"- # print(numSub)",
"- Min = \"\".join([str(j) for j in numSub])",
"- numSub.reverse()",
"- # print(numSub)",
"- Max = \"\".join([str(i) for i in numSub])",
"- num1 = int(Max) - int(Min)",
"- num1 = str(num1)",
"- xxx = list(num1)",
"- while len(xxx) < m:",
"- xxx.insert(0, \"0\")",
"- numSub = [int(xxx[g]) for g in range(m)]",
"- xxxx = \"\".join([str(h) for h in xxx])",
"- count.append(str(xxxx))",
"- answer = is_unique2(count)",
"- iCount += 1",
"- print(count.index(count[-1]), end=\" \")",
"- print(int(count[-1]), end=\" \")",
"- print(str(iCount - count.index(count[-1])))",
"+ while answer: # answerがTrueを受け取ったときこのループを抜けます",
"+ numInt.sort() # numIntのリストの中の数字が昇順に並び替えられます",
"+ Min = \"\".join(",
"+ [str(j) for j in numInt]",
"+ ) # numIntのリストの一文字ずつの数字を全部繋げてstr型としてMinに入れます(数値的には並び替えてできる最小の整数)",
"+ numInt.reverse() # numIntのリストの中の数字が降順に並び替えられます",
"+ Max = \"\".join(",
"+ [str(i) for i in numInt]",
"+ ) # numIntのリストの一文字ずつの数字を全部繋げてstr型としてMaxに入れます(数値的には並び替えてできる最大の整数)",
"+ ax = str(int(Max) - int(Min)) # MaxからMinを引いてAx(x=1~20)の値をstr型でaxに入れます",
"+ numStr = list(",
"+ ax",
"+ ) # axを一文字ずつ分けてnumStrのリストに入れてます(numStrではなく別の関数でも良いが、解りやすい為numStrに入れてます)",
"+ while len(numStr) < L: # 桁数が足りないとき、一番大きな位に０を入れてます",
"+ numStr.insert(0, \"0\")",
"+ numInt = [",
"+ int(numStr[g]) for g in range(L)",
"+ ] # strからintへ型を変えてnumStrをnumIntに入れてます(whileのループ処理のためnumIntに入れてます)",
"+ Ax = \"\".join(",
"+ [str(h) for h in numInt]",
"+ ) # numIntのリストの一文字ずつの数字を全部繋げてstr型としてAx(x=1~20)に入れます(数値的にはax(x=1~20)と同値です)",
"+ count.append(str(Ax)) # a0,a1,a2...aiの値を入れるcountリストの中にAxを入れます",
"+ answer = is_unique2(",
"+ count",
"+ ) # countリスト内に同じ値が二つあるとき、answerはTrueを受け取り、while文のループから抜け出します",
"+ iCount += 1 # 今Ax番目の計算を行ったことを示し、answerがTrueを受け取った際は、それがAi番目となる",
"+ print(count.index(count[-1]), end=\" \") # Ajのjの値を出力(スペース開けて改行しない)",
"+ print(int(count[-1]), end=\" \") # Aiの値を出力(スペース開けて改行しない)",
"+ print(str(iCount - count.index(count[-1]))) # Aiのi-Ajのjの値を出力"
]
| false | 0.079894 | 0.081183 | 0.984125 | [
"s104018993",
"s747616673"
]
|
u392319141 | p03612 | python | s178731794 | s667970289 | 95 | 76 | 13,880 | 14,008 | Accepted | Accepted | 20 | N = int(eval(input()))
P = list([int(a) - 1 for a in input().split()])
ans = 0
for i in range(N):
p = P[i]
if p == i:
if i < N - 1:
P[i], P[i + 1] = P[i + 1], P[i]
ans += 1
print(ans) | N = int(eval(input()))
P = list(map(int, input().split()))
ans = 0
for i in range(N):
if P[i] == i + 1:
if i + 1 < N:
P[i], P[i + 1] = P[i + 1], P[i]
ans += 1
print(ans)
| 12 | 11 | 231 | 208 | N = int(eval(input()))
P = list([int(a) - 1 for a in input().split()])
ans = 0
for i in range(N):
p = P[i]
if p == i:
if i < N - 1:
P[i], P[i + 1] = P[i + 1], P[i]
ans += 1
print(ans)
| N = int(eval(input()))
P = list(map(int, input().split()))
ans = 0
for i in range(N):
if P[i] == i + 1:
if i + 1 < N:
P[i], P[i + 1] = P[i + 1], P[i]
ans += 1
print(ans)
| false | 8.333333 | [
"-P = list([int(a) - 1 for a in input().split()])",
"+P = list(map(int, input().split()))",
"- p = P[i]",
"- if p == i:",
"- if i < N - 1:",
"+ if P[i] == i + 1:",
"+ if i + 1 < N:"
]
| false | 0.104094 | 0.06765 | 1.538721 | [
"s178731794",
"s667970289"
]
|
u130900604 | p02601 | python | s425076310 | s821597937 | 82 | 64 | 61,716 | 61,848 | Accepted | Accepted | 21.95 | def LI():
return list(map(int,input().split()))
red,green,blue=LI()
k=int(eval(input()))
for i in range(0,k+1):
r=red
g=green*pow(2,i)
b=blue*pow(2,k-i)
if r<g<b:
print("Yes")
# print(red,green,blue)
exit()
print("No")
| a,b,c=list(map(int,input().split()))
k=int(eval(input()))
for i in range(0,k+1):
if a<b*2**i<c*2**(k-i):
print("Yes")
exit()
print("No") | 19 | 7 | 304 | 140 | def LI():
return list(map(int, input().split()))
red, green, blue = LI()
k = int(eval(input()))
for i in range(0, k + 1):
r = red
g = green * pow(2, i)
b = blue * pow(2, k - i)
if r < g < b:
print("Yes")
# print(red,green,blue)
exit()
print("No")
| a, b, c = list(map(int, input().split()))
k = int(eval(input()))
for i in range(0, k + 1):
if a < b * 2**i < c * 2 ** (k - i):
print("Yes")
exit()
print("No")
| false | 63.157895 | [
"-def LI():",
"- return list(map(int, input().split()))",
"-",
"-",
"-red, green, blue = LI()",
"+a, b, c = list(map(int, input().split()))",
"- r = red",
"- g = green * pow(2, i)",
"- b = blue * pow(2, k - i)",
"- if r < g < b:",
"+ if a < b * 2**i < c * 2 ** (k - i):",
"- # print(red,green,blue)"
]
| false | 0.036278 | 0.038095 | 0.952312 | [
"s425076310",
"s821597937"
]
|
u636684559 | p03031 | python | s593971048 | s605906713 | 51 | 42 | 3,064 | 9,080 | Accepted | Accepted | 17.65 | N,M=list(map(int,input().split()))
S=[]
for i in range(M):
S.append(list(map(int,input().split())))
S[-1]=S[-1][1:]
P=list(map(int,input().split()))
ans=0
for i in range(2**N):
bit=format(i,'0'+str(N)+'b')
bit=list(map(int,bit))
on=0
for s,p in zip(S,P):
check=0
for j in s:
j-=1
check+=bit[j]
if check%2==p:on+=1
if on==M:ans+=1
print(ans) | n,m=list(map(int,input().split()))
K=[]
S=[]
for i in range(m):
tmp=list(map(int,input().split()))
K.append(tmp[0])
S.append(tmp[1:])
P=list(map(int,input().split()))
ans=0
for i in range(2**n):
bit=format(i,'0'+str(n)+'b')
bit=list(map(int,bit))
on_den=0
for den in range(m):
on_swi=0
for s in S[den]:
on_swi+=bit[s-1]
if on_swi%2==P[den]:
on_den+=1
if on_den==m:
ans+=1
print(ans) | 20 | 22 | 394 | 441 | N, M = list(map(int, input().split()))
S = []
for i in range(M):
S.append(list(map(int, input().split())))
S[-1] = S[-1][1:]
P = list(map(int, input().split()))
ans = 0
for i in range(2**N):
bit = format(i, "0" + str(N) + "b")
bit = list(map(int, bit))
on = 0
for s, p in zip(S, P):
check = 0
for j in s:
j -= 1
check += bit[j]
if check % 2 == p:
on += 1
if on == M:
ans += 1
print(ans)
| n, m = list(map(int, input().split()))
K = []
S = []
for i in range(m):
tmp = list(map(int, input().split()))
K.append(tmp[0])
S.append(tmp[1:])
P = list(map(int, input().split()))
ans = 0
for i in range(2**n):
bit = format(i, "0" + str(n) + "b")
bit = list(map(int, bit))
on_den = 0
for den in range(m):
on_swi = 0
for s in S[den]:
on_swi += bit[s - 1]
if on_swi % 2 == P[den]:
on_den += 1
if on_den == m:
ans += 1
print(ans)
| false | 9.090909 | [
"-N, M = list(map(int, input().split()))",
"+n, m = list(map(int, input().split()))",
"+K = []",
"-for i in range(M):",
"- S.append(list(map(int, input().split())))",
"- S[-1] = S[-1][1:]",
"+for i in range(m):",
"+ tmp = list(map(int, input().split()))",
"+ K.append(tmp[0])",
"+ S.append(tmp[1:])",
"-for i in range(2**N):",
"- bit = format(i, \"0\" + str(N) + \"b\")",
"+for i in range(2**n):",
"+ bit = format(i, \"0\" + str(n) + \"b\")",
"- on = 0",
"- for s, p in zip(S, P):",
"- check = 0",
"- for j in s:",
"- j -= 1",
"- check += bit[j]",
"- if check % 2 == p:",
"- on += 1",
"- if on == M:",
"+ on_den = 0",
"+ for den in range(m):",
"+ on_swi = 0",
"+ for s in S[den]:",
"+ on_swi += bit[s - 1]",
"+ if on_swi % 2 == P[den]:",
"+ on_den += 1",
"+ if on_den == m:"
]
| false | 0.05622 | 0.037425 | 1.502195 | [
"s593971048",
"s605906713"
]
|
u426534722 | p02288 | python | s078785289 | s843970253 | 820 | 690 | 63,704 | 63,932 | Accepted | Accepted | 15.85 | H = int(eval(input()))
L = list(map(int, input().split()))
def maxHeapify(A, i):
l = i * 2 + 1
r = i * 2 + 2
if l < H and A[l] > A[i]:
largest = l
else:
largest = i
if r < H and A[r] > A[largest]:
largest = r
if largest != i:
A[i], A[largest] = A[largest], A[i]
maxHeapify(A, largest)
def buildMaxHeap(A):
for i in range(H // 2, -1, -1):
maxHeapify(A, i)
buildMaxHeap(L)
print(("", *L))
| H = int(eval(input()))
L = list(map(int, input().split()))
def maxHeapify(A, i):
l = i * 2 + 1
r = i * 2 + 2
if l < H and A[l] > A[i]:
largest = l
else:
largest = i
if r < H and A[r] > A[largest]:
largest = r
if largest != i:
A[i], A[largest] = A[largest], A[i]
maxHeapify(A, largest)
def buildMaxHeap(A):
for i in range(H // 2, -1, -1):
maxHeapify(A, i)
buildMaxHeap(L)
print(("", " ".join(map(str, L))))
| 20 | 20 | 475 | 494 | H = int(eval(input()))
L = list(map(int, input().split()))
def maxHeapify(A, i):
l = i * 2 + 1
r = i * 2 + 2
if l < H and A[l] > A[i]:
largest = l
else:
largest = i
if r < H and A[r] > A[largest]:
largest = r
if largest != i:
A[i], A[largest] = A[largest], A[i]
maxHeapify(A, largest)
def buildMaxHeap(A):
for i in range(H // 2, -1, -1):
maxHeapify(A, i)
buildMaxHeap(L)
print(("", *L))
| H = int(eval(input()))
L = list(map(int, input().split()))
def maxHeapify(A, i):
l = i * 2 + 1
r = i * 2 + 2
if l < H and A[l] > A[i]:
largest = l
else:
largest = i
if r < H and A[r] > A[largest]:
largest = r
if largest != i:
A[i], A[largest] = A[largest], A[i]
maxHeapify(A, largest)
def buildMaxHeap(A):
for i in range(H // 2, -1, -1):
maxHeapify(A, i)
buildMaxHeap(L)
print(("", " ".join(map(str, L))))
| false | 0 | [
"-print((\"\", *L))",
"+print((\"\", \" \".join(map(str, L))))"
]
| false | 0.03522 | 0.031672 | 1.112018 | [
"s078785289",
"s843970253"
]
|
u588341295 | p03088 | python | s054424753 | s826749055 | 128 | 117 | 4,424 | 4,340 | Accepted | Accepted | 8.59 | # -*- coding: utf-8 -*-
"""
参考：https://img.atcoder.jp/abc122/editorial.pdf
・数え上げDP
・正規表現
"""
import sys, re
from itertools import product
from collections import Counter
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7
N=INT()
# NGパターン一覧
patterns = [
# 任意の0か1文字
re.compile(r'^(.?)AGC(.?)$'),
re.compile(r'^(.?)GAC(.?)$'),
re.compile(r'^(.?)ACG(.?)$'),
# 任意の1文字
re.compile(r'^A.GC$'),
re.compile(r'^AG.C$'),
]
# dp[i][j] := 全部でi文字の時、最後の3文字がjとなる文字列の数
dp=[Counter() for i in range(N+1)]
keys = [''.join(key) for key in product('ACGT', repeat=3)]
# 3文字での初期値
for key in keys:
if key not in ['AGC', 'GAC', 'ACG']:
dp[3][key]=1
else:
dp[3][key]=0
for i in range(4, N+1):
for key in keys:
for nxt in 'ACGT':
# NGパターンのいずれにもマッチしないものだけ遷移させる
if not any([ptn.match(key+nxt) for ptn in patterns]):
dp[i][key[1:]+nxt]=(dp[i][key[1:]+nxt]+dp[i-1][key])%MOD
print(((sum(dp[N].values()))%MOD))
| # -*- coding: utf-8 -*-
"""
参考：https://img.atcoder.jp/abc122/editorial.pdf
・数え上げDP
・正規表現
"""
import sys, re
from itertools import product
from collections import Counter
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7
N=INT()
# NGパターン一覧
patterns = [
# 任意の0か1文字
re.compile(r'^(.?)AGC(.?)$'),
re.compile(r'^(.?)GAC(.?)$'),
re.compile(r'^(.?)ACG(.?)$'),
# 任意の1文字
re.compile(r'^A.GC$'),
re.compile(r'^AG.C$'),
]
# dp[i][j] := 全部でi文字の時、最後の3文字がjとなる文字列の数
dp=[Counter() for i in range(N+1)]
keys = [''.join(key) for key in product('ACGT', repeat=3)]
# 3文字での初期値
for key in keys:
if key not in ['AGC', 'GAC', 'ACG']:
dp[3][key]=1
keys = [''.join(key) for key in product('ACGT', repeat=4)]
for i in range(4, N+1):
for key in keys:
# NGパターンのいずれにもマッチしないものだけ遷移させる
if not any([ptn.match(key) for ptn in patterns]):
cur,nxt=key[:3],key[1:]
dp[i][nxt]=(dp[i][nxt]+dp[i-1][cur])%MOD
print(((sum(dp[N].values()))%MOD))
| 57 | 56 | 1,503 | 1,507 | # -*- coding: utf-8 -*-
"""
参考：https://img.atcoder.jp/abc122/editorial.pdf
・数え上げDP
・正規表現
"""
import sys, re
from itertools import product
from collections import Counter
def input():
return sys.stdin.readline().strip()
def list2d(a, b, c):
return [[c] * b for i in range(a)]
def list3d(a, b, c, d):
return [[[d] * c for j in range(b)] for i in range(a)]
def ceil(x, y=1):
return int(-(-x // y))
def INT():
return int(eval(input()))
def MAP():
return list(map(int, input().split()))
def LIST():
return list(map(int, input().split()))
def Yes():
print("Yes")
def No():
print("No")
def YES():
print("YES")
def NO():
print("NO")
sys.setrecursionlimit(10**9)
INF = float("inf")
MOD = 10**9 + 7
N = INT()
# NGパターン一覧
patterns = [
# 任意の0か1文字
re.compile(r"^(.?)AGC(.?)$"),
re.compile(r"^(.?)GAC(.?)$"),
re.compile(r"^(.?)ACG(.?)$"),
# 任意の1文字
re.compile(r"^A.GC$"),
re.compile(r"^AG.C$"),
]
# dp[i][j] := 全部でi文字の時、最後の3文字がjとなる文字列の数
dp = [Counter() for i in range(N + 1)]
keys = ["".join(key) for key in product("ACGT", repeat=3)]
# 3文字での初期値
for key in keys:
if key not in ["AGC", "GAC", "ACG"]:
dp[3][key] = 1
else:
dp[3][key] = 0
for i in range(4, N + 1):
for key in keys:
for nxt in "ACGT":
# NGパターンのいずれにもマッチしないものだけ遷移させる
if not any([ptn.match(key + nxt) for ptn in patterns]):
dp[i][key[1:] + nxt] = (dp[i][key[1:] + nxt] + dp[i - 1][key]) % MOD
print(((sum(dp[N].values())) % MOD))
| # -*- coding: utf-8 -*-
"""
参考：https://img.atcoder.jp/abc122/editorial.pdf
・数え上げDP
・正規表現
"""
import sys, re
from itertools import product
from collections import Counter
def input():
return sys.stdin.readline().strip()
def list2d(a, b, c):
return [[c] * b for i in range(a)]
def list3d(a, b, c, d):
return [[[d] * c for j in range(b)] for i in range(a)]
def ceil(x, y=1):
return int(-(-x // y))
def INT():
return int(eval(input()))
def MAP():
return list(map(int, input().split()))
def LIST():
return list(map(int, input().split()))
def Yes():
print("Yes")
def No():
print("No")
def YES():
print("YES")
def NO():
print("NO")
sys.setrecursionlimit(10**9)
INF = float("inf")
MOD = 10**9 + 7
N = INT()
# NGパターン一覧
patterns = [
# 任意の0か1文字
re.compile(r"^(.?)AGC(.?)$"),
re.compile(r"^(.?)GAC(.?)$"),
re.compile(r"^(.?)ACG(.?)$"),
# 任意の1文字
re.compile(r"^A.GC$"),
re.compile(r"^AG.C$"),
]
# dp[i][j] := 全部でi文字の時、最後の3文字がjとなる文字列の数
dp = [Counter() for i in range(N + 1)]
keys = ["".join(key) for key in product("ACGT", repeat=3)]
# 3文字での初期値
for key in keys:
if key not in ["AGC", "GAC", "ACG"]:
dp[3][key] = 1
keys = ["".join(key) for key in product("ACGT", repeat=4)]
for i in range(4, N + 1):
for key in keys:
# NGパターンのいずれにもマッチしないものだけ遷移させる
if not any([ptn.match(key) for ptn in patterns]):
cur, nxt = key[:3], key[1:]
dp[i][nxt] = (dp[i][nxt] + dp[i - 1][cur]) % MOD
print(((sum(dp[N].values())) % MOD))
| false | 1.754386 | [
"- else:",
"- dp[3][key] = 0",
"+keys = [\"\".join(key) for key in product(\"ACGT\", repeat=4)]",
"- for nxt in \"ACGT\":",
"- # NGパターンのいずれにもマッチしないものだけ遷移させる",
"- if not any([ptn.match(key + nxt) for ptn in patterns]):",
"- dp[i][key[1:] + nxt] = (dp[i][key[1:] + nxt] + dp[i - 1][key]) % MOD",
"+ # NGパターンのいずれにもマッチしないものだけ遷移させる",
"+ if not any([ptn.match(key) for ptn in patterns]):",
"+ cur, nxt = key[:3], key[1:]",
"+ dp[i][nxt] = (dp[i][nxt] + dp[i - 1][cur]) % MOD"
]
| false | 0.06467 | 0.06157 | 1.050339 | [
"s054424753",
"s826749055"
]
|
u604774382 | p02270 | python | s231305975 | s015656907 | 1,690 | 900 | 11,136 | 10,476 | Accepted | Accepted | 46.75 | n, k = [ int( val ) for val in input( ).split( " " ) ]
w = []
maxW = sumW = 0
for i in range( n ):
num = int( eval(input( )) )
sumW += num
w.append( num )
if maxW < num:
maxW = num
minP = 0
if 1 == k:
minP = sumW
elif n == k:
minP = maxW
else:
left = maxW
right = 100000*10000
while left <= right:
middle = ( left+right )//2
truckCnt = i = loadings = 0
while i < n:
loadings += w[i]
if middle < loadings:
truckCnt += 1
if k < truckCnt+1:
break
loadings = w[i]
i += 1
if truckCnt+1 <= k:
minP = middle
if k < truckCnt+1:
left = middle + 1
else:
right = middle - 1
print( minP ) | n, k = [ int( val ) for val in input( ).split( " " ) ]
w = [ int( input( ) ) for val in range( n ) ]
sumW = sum( w )
maxW = max( w )
minP = 0
if 1 == k:
minP = sumW
elif n == k:
minP = maxW
else:
left = maxW
right = 100000*10000
while left <= right:
middle = ( left+right )//2
truckCnt = i = loadings = 0
while i < n:
loadings += w[i]
if middle < loadings:
truckCnt += 1
if k < truckCnt+1:
break
loadings = w[i]
i += 1
if truckCnt+1 <= k:
minP = middle
if k < truckCnt+1:
left = middle + 1
else:
right = middle - 1
print( minP ) | 39 | 34 | 672 | 627 | n, k = [int(val) for val in input().split(" ")]
w = []
maxW = sumW = 0
for i in range(n):
num = int(eval(input()))
sumW += num
w.append(num)
if maxW < num:
maxW = num
minP = 0
if 1 == k:
minP = sumW
elif n == k:
minP = maxW
else:
left = maxW
right = 100000 * 10000
while left <= right:
middle = (left + right) // 2
truckCnt = i = loadings = 0
while i < n:
loadings += w[i]
if middle < loadings:
truckCnt += 1
if k < truckCnt + 1:
break
loadings = w[i]
i += 1
if truckCnt + 1 <= k:
minP = middle
if k < truckCnt + 1:
left = middle + 1
else:
right = middle - 1
print(minP)
| n, k = [int(val) for val in input().split(" ")]
w = [int(input()) for val in range(n)]
sumW = sum(w)
maxW = max(w)
minP = 0
if 1 == k:
minP = sumW
elif n == k:
minP = maxW
else:
left = maxW
right = 100000 * 10000
while left <= right:
middle = (left + right) // 2
truckCnt = i = loadings = 0
while i < n:
loadings += w[i]
if middle < loadings:
truckCnt += 1
if k < truckCnt + 1:
break
loadings = w[i]
i += 1
if truckCnt + 1 <= k:
minP = middle
if k < truckCnt + 1:
left = middle + 1
else:
right = middle - 1
print(minP)
| false | 12.820513 | [
"-w = []",
"-maxW = sumW = 0",
"-for i in range(n):",
"- num = int(eval(input()))",
"- sumW += num",
"- w.append(num)",
"- if maxW < num:",
"- maxW = num",
"+w = [int(input()) for val in range(n)]",
"+sumW = sum(w)",
"+maxW = max(w)"
]
| false | 0.036896 | 0.07436 | 0.496183 | [
"s231305975",
"s015656907"
]
|
u883048396 | p04000 | python | s431505825 | s976710850 | 1,149 | 955 | 124,132 | 124,104 | Accepted | Accepted | 16.88 | import sys
iH,iW,iN = [int(_) for _ in input().split()]
aD = [[int(_) for _ in sLine.split()] for sLine in sys.stdin.readlines()]
iMax = (iH - 2) * (iW -2)
#print (iMax)
dC={}
for i in range(10):
dC[i]=0
#愚直 無理 つらい
#for i in range(1,iH -1):
# for j in range(1,iW-1):
# tmp = 0
# for a in aD:
# if j<= a[1] <=j+2 and i<= a[0] <= i+2:
# tmp +=1
# dC[tmp] +=1
dM = {}
for a in aD:
y=a[0]
x=a[1]
for aP in [(y-2,x-2),(y-2,x-1),(y-2,x),(y-1,x-2),(y-1,x-1),(y-1,x),(y,x-2),(y,x-1),(y,x)]:
if 0< aP[0]<iH-1 and 0 < aP[1] < iW-1:
iP = aP[0]*iW + aP[1]
if iP in dM:
dM[iP] += 1
else:
dM[iP] = 1
for i in dM:
dC[dM[i]]+=1
iAllBM=0
for i in range(1,10):
iAllBM+=dC[i]
dC[0] = iMax -iAllBM
for i in range(10):
print((dC[i]))
| import sys
def 解():
iH,iW,iN = [int(_) for _ in input().split()]
aD = [[int(_) for _ in sLine.split()] for sLine in sys.stdin.readlines()]
iMax = (iH - 2) * (iW -2)
#print (iMax)
dC={}
for i in range(10):
dC[i]=0
#愚直 無理 つらい
#for i in range(1,iH -1):
# for j in range(1,iW-1):
# tmp = 0
# for a in aD:
# if j<= a[1] <=j+2 and i<= a[0] <= i+2:
# tmp +=1
# dC[tmp] +=1
#なんというか、面倒くさくなって解法みても
#面倒くさがらずやれとしか書いてなくてつらい
dM = {}
for a in aD:
y=a[0]
x=a[1]
for aP in [(y-2,x-2),(y-2,x-1),(y-2,x),(y-1,x-2),(y-1,x-1),(y-1,x),(y,x-2),(y,x-1),(y,x)]:
if 0< aP[0]<iH-1 and 0 < aP[1] < iW-1:
iP = aP[0]*iW + aP[1]
if iP in dM: #もう最初から足したったらええんや
dM[iP] += 1
else:
dM[iP] = 1
for i in dM:
dC[dM[i]]+=1
iAllBM=0
for i in range(1,10):
iAllBM+=dC[i]
dC[0] = iMax -iAllBM #点のないマス0は引き算で出せる
for i in range(10):
print((dC[i]))
解()
| 40 | 45 | 903 | 1,146 | import sys
iH, iW, iN = [int(_) for _ in input().split()]
aD = [[int(_) for _ in sLine.split()] for sLine in sys.stdin.readlines()]
iMax = (iH - 2) * (iW - 2)
# print (iMax)
dC = {}
for i in range(10):
dC[i] = 0
# 愚直 無理 つらい
# for i in range(1,iH -1):
# for j in range(1,iW-1):
# tmp = 0
# for a in aD:
# if j<= a[1] <=j+2 and i<= a[0] <= i+2:
# tmp +=1
# dC[tmp] +=1
dM = {}
for a in aD:
y = a[0]
x = a[1]
for aP in [
(y - 2, x - 2),
(y - 2, x - 1),
(y - 2, x),
(y - 1, x - 2),
(y - 1, x - 1),
(y - 1, x),
(y, x - 2),
(y, x - 1),
(y, x),
]:
if 0 < aP[0] < iH - 1 and 0 < aP[1] < iW - 1:
iP = aP[0] * iW + aP[1]
if iP in dM:
dM[iP] += 1
else:
dM[iP] = 1
for i in dM:
dC[dM[i]] += 1
iAllBM = 0
for i in range(1, 10):
iAllBM += dC[i]
dC[0] = iMax - iAllBM
for i in range(10):
print((dC[i]))
| import sys
def 解():
iH, iW, iN = [int(_) for _ in input().split()]
aD = [[int(_) for _ in sLine.split()] for sLine in sys.stdin.readlines()]
iMax = (iH - 2) * (iW - 2)
# print (iMax)
dC = {}
for i in range(10):
dC[i] = 0
# 愚直 無理 つらい
# for i in range(1,iH -1):
# for j in range(1,iW-1):
# tmp = 0
# for a in aD:
# if j<= a[1] <=j+2 and i<= a[0] <= i+2:
# tmp +=1
# dC[tmp] +=1
# なんというか、面倒くさくなって解法みても
# 面倒くさがらずやれとしか書いてなくてつらい
dM = {}
for a in aD:
y = a[0]
x = a[1]
for aP in [
(y - 2, x - 2),
(y - 2, x - 1),
(y - 2, x),
(y - 1, x - 2),
(y - 1, x - 1),
(y - 1, x),
(y, x - 2),
(y, x - 1),
(y, x),
]:
if 0 < aP[0] < iH - 1 and 0 < aP[1] < iW - 1:
iP = aP[0] * iW + aP[1]
if iP in dM: # もう最初から足したったらええんや
dM[iP] += 1
else:
dM[iP] = 1
for i in dM:
dC[dM[i]] += 1
iAllBM = 0
for i in range(1, 10):
iAllBM += dC[i]
dC[0] = iMax - iAllBM # 点のないマス0は引き算で出せる
for i in range(10):
print((dC[i]))
解()
| false | 11.111111 | [
"-iH, iW, iN = [int(_) for _ in input().split()]",
"-aD = [[int(_) for _ in sLine.split()] for sLine in sys.stdin.readlines()]",
"-iMax = (iH - 2) * (iW - 2)",
"-# print (iMax)",
"-dC = {}",
"-for i in range(10):",
"- dC[i] = 0",
"-# 愚直 無理 つらい",
"-# for i in range(1,iH -1):",
"-# for j in range(1,iW-1):",
"-# tmp = 0",
"-# for a in aD:",
"-# if j<= a[1] <=j+2 and i<= a[0] <= i+2:",
"-# tmp +=1",
"-# dC[tmp] +=1",
"-dM = {}",
"-for a in aD:",
"- y = a[0]",
"- x = a[1]",
"- for aP in [",
"- (y - 2, x - 2),",
"- (y - 2, x - 1),",
"- (y - 2, x),",
"- (y - 1, x - 2),",
"- (y - 1, x - 1),",
"- (y - 1, x),",
"- (y, x - 2),",
"- (y, x - 1),",
"- (y, x),",
"- ]:",
"- if 0 < aP[0] < iH - 1 and 0 < aP[1] < iW - 1:",
"- iP = aP[0] * iW + aP[1]",
"- if iP in dM:",
"- dM[iP] += 1",
"- else:",
"- dM[iP] = 1",
"-for i in dM:",
"- dC[dM[i]] += 1",
"-iAllBM = 0",
"-for i in range(1, 10):",
"- iAllBM += dC[i]",
"-dC[0] = iMax - iAllBM",
"-for i in range(10):",
"- print((dC[i]))",
"+",
"+def 解():",
"+ iH, iW, iN = [int(_) for _ in input().split()]",
"+ aD = [[int(_) for _ in sLine.split()] for sLine in sys.stdin.readlines()]",
"+ iMax = (iH - 2) * (iW - 2)",
"+ # print (iMax)",
"+ dC = {}",
"+ for i in range(10):",
"+ dC[i] = 0",
"+ # 愚直 無理 つらい",
"+ # for i in range(1,iH -1):",
"+ # for j in range(1,iW-1):",
"+ # tmp = 0",
"+ # for a in aD:",
"+ # if j<= a[1] <=j+2 and i<= a[0] <= i+2:",
"+ # tmp +=1",
"+ # dC[tmp] +=1",
"+ # なんというか、面倒くさくなって解法みても",
"+ # 面倒くさがらずやれとしか書いてなくてつらい",
"+ dM = {}",
"+ for a in aD:",
"+ y = a[0]",
"+ x = a[1]",
"+ for aP in [",
"+ (y - 2, x - 2),",
"+ (y - 2, x - 1),",
"+ (y - 2, x),",
"+ (y - 1, x - 2),",
"+ (y - 1, x - 1),",
"+ (y - 1, x),",
"+ (y, x - 2),",
"+ (y, x - 1),",
"+ (y, x),",
"+ ]:",
"+ if 0 < aP[0] < iH - 1 and 0 < aP[1] < iW - 1:",
"+ iP = aP[0] * iW + aP[1]",
"+ if iP in dM: # もう最初から足したったらええんや",
"+ dM[iP] += 1",
"+ else:",
"+ dM[iP] = 1",
"+ for i in dM:",
"+ dC[dM[i]] += 1",
"+ iAllBM = 0",
"+ for i in range(1, 10):",
"+ iAllBM += dC[i]",
"+ dC[0] = iMax - iAllBM # 点のないマス0は引き算で出せる",
"+ for i in range(10):",
"+ print((dC[i]))",
"+",
"+",
"+解()"
]
| false | 0.04298 | 0.037145 | 1.15709 | [
"s431505825",
"s976710850"
]
|
u566428756 | p03107 | python | s648221682 | s781991480 | 34 | 21 | 3,956 | 3,956 | Accepted | Accepted | 38.24 | s=list(eval(input()))
len_s=len(s)
cnt_1=0
for i in range(len_s):
if s[i]=='1':
cnt_1+=1
cnt_0=len_s-cnt_1
print((min(cnt_1,cnt_0)*2)) | s=list(eval(input()))
cnt_1=s.count('1')
MIN=min(len(s)-cnt_1,cnt_1)
print((MIN*2)) | 8 | 4 | 145 | 78 | s = list(eval(input()))
len_s = len(s)
cnt_1 = 0
for i in range(len_s):
if s[i] == "1":
cnt_1 += 1
cnt_0 = len_s - cnt_1
print((min(cnt_1, cnt_0) * 2))
| s = list(eval(input()))
cnt_1 = s.count("1")
MIN = min(len(s) - cnt_1, cnt_1)
print((MIN * 2))
| false | 50 | [
"-len_s = len(s)",
"-cnt_1 = 0",
"-for i in range(len_s):",
"- if s[i] == \"1\":",
"- cnt_1 += 1",
"-cnt_0 = len_s - cnt_1",
"-print((min(cnt_1, cnt_0) * 2))",
"+cnt_1 = s.count(\"1\")",
"+MIN = min(len(s) - cnt_1, cnt_1)",
"+print((MIN * 2))"
]
| false | 0.08528 | 0.04517 | 1.888004 | [
"s648221682",
"s781991480"
]
|
u476604182 | p02821 | python | s826265725 | s141660709 | 1,482 | 373 | 14,696 | 23,088 | Accepted | Accepted | 74.83 | from bisect import bisect_left
from itertools import accumulate
N,M,*A = list(map(int, open(0).read().split()))
A.sort()
B = list(accumulate(A[::-1]))
l = -1
r = 10**6
while l+1<r:
s = (l+r)//2
cnt = 0
for c in A:
i = bisect_left(A,s-c)
cnt += N-i
if cnt>=M:
l = s
else:
r = s
ans = 0
for c in A:
i = bisect_left(A,r-c)
M -= N-i
if i<N:
ans += B[N-1-i]+c*(N-i)
ans += M*l
print(ans)
| import numpy as np
N,M,*A = list(map(int, open(0).read().split()))
A = np.sort(A)
B = np.cumsum(np.concatenate([[0],A[::-1]]))
l = -1
r = 10**6
while l+1<r:
s = (l+r)//2
cnt = np.sum(N-np.searchsorted(A,s-A))
if cnt>=M:
l = s
else:
r = s
ind = np.searchsorted(A,r-A)
M -= np.sum(N-ind)
ans = np.sum(B[N-ind]+A*(N-ind))+M*l
print(ans)
| 25 | 17 | 437 | 360 | from bisect import bisect_left
from itertools import accumulate
N, M, *A = list(map(int, open(0).read().split()))
A.sort()
B = list(accumulate(A[::-1]))
l = -1
r = 10**6
while l + 1 < r:
s = (l + r) // 2
cnt = 0
for c in A:
i = bisect_left(A, s - c)
cnt += N - i
if cnt >= M:
l = s
else:
r = s
ans = 0
for c in A:
i = bisect_left(A, r - c)
M -= N - i
if i < N:
ans += B[N - 1 - i] + c * (N - i)
ans += M * l
print(ans)
| import numpy as np
N, M, *A = list(map(int, open(0).read().split()))
A = np.sort(A)
B = np.cumsum(np.concatenate([[0], A[::-1]]))
l = -1
r = 10**6
while l + 1 < r:
s = (l + r) // 2
cnt = np.sum(N - np.searchsorted(A, s - A))
if cnt >= M:
l = s
else:
r = s
ind = np.searchsorted(A, r - A)
M -= np.sum(N - ind)
ans = np.sum(B[N - ind] + A * (N - ind)) + M * l
print(ans)
| false | 32 | [
"-from bisect import bisect_left",
"-from itertools import accumulate",
"+import numpy as np",
"-A.sort()",
"-B = list(accumulate(A[::-1]))",
"+A = np.sort(A)",
"+B = np.cumsum(np.concatenate([[0], A[::-1]]))",
"- cnt = 0",
"- for c in A:",
"- i = bisect_left(A, s - c)",
"- cnt += N - i",
"+ cnt = np.sum(N - np.searchsorted(A, s - A))",
"-ans = 0",
"-for c in A:",
"- i = bisect_left(A, r - c)",
"- M -= N - i",
"- if i < N:",
"- ans += B[N - 1 - i] + c * (N - i)",
"-ans += M * l",
"+ind = np.searchsorted(A, r - A)",
"+M -= np.sum(N - ind)",
"+ans = np.sum(B[N - ind] + A * (N - ind)) + M * l"
]
| false | 0.04602 | 0.250823 | 0.183476 | [
"s826265725",
"s141660709"
]
|
u761320129 | p03857 | python | s529743607 | s685131358 | 1,788 | 1,466 | 80,492 | 74,908 | Accepted | Accepted | 18.01 | from collections import Counter
N,K,L = list(map(int,input().split()))
P = [tuple(map(int,input().split())) for i in range(K)]
R = [tuple(map(int,input().split())) for i in range(L)]
class UnionFind:
def __init__(self,N):
self.parent = [i for i in range(N)]
self.rank = [0] * N
self.count = 0
def root(self,a):
if self.parent[a] == a:
return a
else:
self.parent[a] = self.root(self.parent[a])
return self.parent[a]
def is_same(self,a,b):
return self.root(a) == self.root(b)
def unite(self,a,b):
ra = self.root(a)
rb = self.root(b)
if ra == rb: return
if self.rank[ra] < self.rank[rb]:
self.parent[ra] = rb
else:
self.parent[rb] = ra
if self.rank[ra] == self.rank[rb]: self.rank[ra] += 1
self.count += 1
uf1 = UnionFind(N)
for p,q in P:
p,q = p-1,q-1
if uf1.is_same(p,q): continue
uf1.unite(p,q)
uf2 = UnionFind(N)
for r,s in R:
r,s = r-1,s-1
if uf2.is_same(r,s): continue
uf2.unite(r,s)
pairs = Counter()
for i in range(N):
a = uf1.root(i)
b = uf2.root(i)
pairs[(a,b)] += 1
ans = []
for i in range(N):
a = uf1.root(i)
b = uf2.root(i)
ans.append(pairs[(a,b)])
print((*ans)) | N,K,L = list(map(int,input().split()))
PQ = [tuple(map(int,input().split())) for i in range(K)]
RS = [tuple(map(int,input().split())) for i in range(L)]
class UnionFind:
def __init__(self,N):
self.parent = [i for i in range(N)]
self.rank = [0] * N
self.count = 0
def root(self,a):
if self.parent[a] == a:
return a
else:
self.parent[a] = self.root(self.parent[a])
return self.parent[a]
def is_same(self,a,b):
return self.root(a) == self.root(b)
def unite(self,a,b):
ra = self.root(a)
rb = self.root(b)
if ra == rb: return
if self.rank[ra] < self.rank[rb]:
self.parent[ra] = rb
else:
self.parent[rb] = ra
if self.rank[ra] == self.rank[rb]: self.rank[ra] += 1
self.count += 1
roads = UnionFind(N)
rails = UnionFind(N)
for p,q in PQ:
p,q = p-1,q-1
roads.unite(p,q)
for r,s in RS:
r,s = r-1,s-1
rails.unite(r,s)
for i in range(N):
roads.root(i)
rails.root(i)
from collections import Counter
ctr = Counter()
for i in range(N):
ctr[(roads.parent[i], rails.parent[i])] += 1
ans = []
for i in range(N):
ans.append(ctr[(roads.parent[i], rails.parent[i])])
print((*ans)) | 53 | 48 | 1,353 | 1,317 | from collections import Counter
N, K, L = list(map(int, input().split()))
P = [tuple(map(int, input().split())) for i in range(K)]
R = [tuple(map(int, input().split())) for i in range(L)]
class UnionFind:
def __init__(self, N):
self.parent = [i for i in range(N)]
self.rank = [0] * N
self.count = 0
def root(self, a):
if self.parent[a] == a:
return a
else:
self.parent[a] = self.root(self.parent[a])
return self.parent[a]
def is_same(self, a, b):
return self.root(a) == self.root(b)
def unite(self, a, b):
ra = self.root(a)
rb = self.root(b)
if ra == rb:
return
if self.rank[ra] < self.rank[rb]:
self.parent[ra] = rb
else:
self.parent[rb] = ra
if self.rank[ra] == self.rank[rb]:
self.rank[ra] += 1
self.count += 1
uf1 = UnionFind(N)
for p, q in P:
p, q = p - 1, q - 1
if uf1.is_same(p, q):
continue
uf1.unite(p, q)
uf2 = UnionFind(N)
for r, s in R:
r, s = r - 1, s - 1
if uf2.is_same(r, s):
continue
uf2.unite(r, s)
pairs = Counter()
for i in range(N):
a = uf1.root(i)
b = uf2.root(i)
pairs[(a, b)] += 1
ans = []
for i in range(N):
a = uf1.root(i)
b = uf2.root(i)
ans.append(pairs[(a, b)])
print((*ans))
| N, K, L = list(map(int, input().split()))
PQ = [tuple(map(int, input().split())) for i in range(K)]
RS = [tuple(map(int, input().split())) for i in range(L)]
class UnionFind:
def __init__(self, N):
self.parent = [i for i in range(N)]
self.rank = [0] * N
self.count = 0
def root(self, a):
if self.parent[a] == a:
return a
else:
self.parent[a] = self.root(self.parent[a])
return self.parent[a]
def is_same(self, a, b):
return self.root(a) == self.root(b)
def unite(self, a, b):
ra = self.root(a)
rb = self.root(b)
if ra == rb:
return
if self.rank[ra] < self.rank[rb]:
self.parent[ra] = rb
else:
self.parent[rb] = ra
if self.rank[ra] == self.rank[rb]:
self.rank[ra] += 1
self.count += 1
roads = UnionFind(N)
rails = UnionFind(N)
for p, q in PQ:
p, q = p - 1, q - 1
roads.unite(p, q)
for r, s in RS:
r, s = r - 1, s - 1
rails.unite(r, s)
for i in range(N):
roads.root(i)
rails.root(i)
from collections import Counter
ctr = Counter()
for i in range(N):
ctr[(roads.parent[i], rails.parent[i])] += 1
ans = []
for i in range(N):
ans.append(ctr[(roads.parent[i], rails.parent[i])])
print((*ans))
| false | 9.433962 | [
"-from collections import Counter",
"-",
"-P = [tuple(map(int, input().split())) for i in range(K)]",
"-R = [tuple(map(int, input().split())) for i in range(L)]",
"+PQ = [tuple(map(int, input().split())) for i in range(K)]",
"+RS = [tuple(map(int, input().split())) for i in range(L)]",
"-uf1 = UnionFind(N)",
"-for p, q in P:",
"+roads = UnionFind(N)",
"+rails = UnionFind(N)",
"+for p, q in PQ:",
"- if uf1.is_same(p, q):",
"- continue",
"- uf1.unite(p, q)",
"-uf2 = UnionFind(N)",
"-for r, s in R:",
"+ roads.unite(p, q)",
"+for r, s in RS:",
"- if uf2.is_same(r, s):",
"- continue",
"- uf2.unite(r, s)",
"-pairs = Counter()",
"+ rails.unite(r, s)",
"- a = uf1.root(i)",
"- b = uf2.root(i)",
"- pairs[(a, b)] += 1",
"+ roads.root(i)",
"+ rails.root(i)",
"+from collections import Counter",
"+",
"+ctr = Counter()",
"+for i in range(N):",
"+ ctr[(roads.parent[i], rails.parent[i])] += 1",
"- a = uf1.root(i)",
"- b = uf2.root(i)",
"- ans.append(pairs[(a, b)])",
"+ ans.append(ctr[(roads.parent[i], rails.parent[i])])"
]
| false | 0.114513 | 0.114097 | 1.003649 | [
"s529743607",
"s685131358"
]
|
u597374218 | p02993 | python | s070540045 | s140939913 | 32 | 26 | 8,756 | 8,944 | Accepted | Accepted | 18.75 | S=eval(input())
print(("Good" if S[0]!=S[1]!=S[2]!=S[3] else "Bad")) | a,b,c,d=eval(input())
print(("Good" if a!=b!=c!=d else "Bad")) | 2 | 2 | 61 | 55 | S = eval(input())
print(("Good" if S[0] != S[1] != S[2] != S[3] else "Bad"))
| a, b, c, d = eval(input())
print(("Good" if a != b != c != d else "Bad"))
| false | 0 | [
"-S = eval(input())",
"-print((\"Good\" if S[0] != S[1] != S[2] != S[3] else \"Bad\"))",
"+a, b, c, d = eval(input())",
"+print((\"Good\" if a != b != c != d else \"Bad\"))"
]
| false | 0.038621 | 0.044413 | 0.869586 | [
"s070540045",
"s140939913"
]
|
u738898077 | p03212 | python | s637298763 | s679018445 | 95 | 57 | 2,940 | 3,064 | Accepted | Accepted | 40 | #解説AC,9割写経
n = int(eval(input()))
def dfs(s):
if int(s)>n:
return 0
ret = 1 if all(s.count(c) > 0 for c in "753") else 0
for c in "753":
ret += dfs(s+c)
return ret
print((dfs("0")))
| def dfs(n,a,s):
global ans
temp = int(s)
if temp > n:
return
if "7" in s and "5" in s and "3" in s and n>=temp:
ans += 1
for i in a:
dfs(n,a,s+i)
ans = 0
a = ["7","5","3"]
n = int(eval(input()))
s = "0"
dfs(n,a,s)
print(ans) | 11 | 15 | 217 | 276 | # 解説AC,9割写経
n = int(eval(input()))
def dfs(s):
if int(s) > n:
return 0
ret = 1 if all(s.count(c) > 0 for c in "753") else 0
for c in "753":
ret += dfs(s + c)
return ret
print((dfs("0")))
| def dfs(n, a, s):
global ans
temp = int(s)
if temp > n:
return
if "7" in s and "5" in s and "3" in s and n >= temp:
ans += 1
for i in a:
dfs(n, a, s + i)
ans = 0
a = ["7", "5", "3"]
n = int(eval(input()))
s = "0"
dfs(n, a, s)
print(ans)
| false | 26.666667 | [
"-# 解説AC,9割写経",
"-n = int(eval(input()))",
"+def dfs(n, a, s):",
"+ global ans",
"+ temp = int(s)",
"+ if temp > n:",
"+ return",
"+ if \"7\" in s and \"5\" in s and \"3\" in s and n >= temp:",
"+ ans += 1",
"+ for i in a:",
"+ dfs(n, a, s + i)",
"-def dfs(s):",
"- if int(s) > n:",
"- return 0",
"- ret = 1 if all(s.count(c) > 0 for c in \"753\") else 0",
"- for c in \"753\":",
"- ret += dfs(s + c)",
"- return ret",
"-",
"-",
"-print((dfs(\"0\")))",
"+ans = 0",
"+a = [\"7\", \"5\", \"3\"]",
"+n = int(eval(input()))",
"+s = \"0\"",
"+dfs(n, a, s)",
"+print(ans)"
]
| false | 0.181189 | 0.236358 | 0.766588 | [
"s637298763",
"s679018445"
]
|
u150788544 | p02555 | python | s302586319 | s408818917 | 1,124 | 29 | 128,044 | 9,324 | Accepted | Accepted | 97.42 | n = int(eval(input()))
s = n // 3
def cmb2(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)
total = 0
for i in range(s):
y = n - 3*(i+1)
x = cmb2(y+i,i,p)
total = (total + x) % (10**9+7)
print(total)
| n = int(eval(input()))
s = n // 3
def cmb2(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 = 2000 # 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)
total = 0
for i in range(s):
y = n - 3*(i+1)
x = cmb2(y+i,i,p)
total = (total + x) % (10**9+7)
print(total)
| 29 | 30 | 633 | 633 | n = int(eval(input()))
s = n // 3
def cmb2(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)
total = 0
for i in range(s):
y = n - 3 * (i + 1)
x = cmb2(y + i, i, p)
total = (total + x) % (10**9 + 7)
print(total)
| n = int(eval(input()))
s = n // 3
def cmb2(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 = 2000 # 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)
total = 0
for i in range(s):
y = n - 3 * (i + 1)
x = cmb2(y + i, i, p)
total = (total + x) % (10**9 + 7)
print(total)
| false | 3.333333 | [
"-N = 10**6 # N は必要分だけ用意する",
"+N = 2000 # N は必要分だけ用意する"
]
| false | 2.996387 | 0.045932 | 65.235309 | [
"s302586319",
"s408818917"
]
|
u512212329 | p02642 | python | s753754029 | s741619275 | 370 | 287 | 32,084 | 32,232 | Accepted | Accepted | 22.43 | def main():
numbers = int(eval(input()))
array = [int(x) for x in input().split()]
maximum = 1000001
counter = [0] * maximum
for x in array:
if counter[x] != 0:
counter[x] = 2
continue
else:
for multiple in range(x, maximum, x):
counter[multiple] += 1
ans = 0
for x in array:
if counter[x] == 1:
ans += 1
print(ans)
if __name__ == '__main__':
main()
| def main():
eval(input())
array = sorted(int(x) for x in input().split())
maximum = 1000001
counter = [0] * maximum
for x in array:
if counter[x] != 0:
counter[x] = 2
continue
else:
for multiple in range(x, maximum, x):
counter[multiple] += 1
ans = 0
for x in array:
if counter[x] == 1:
ans += 1
print(ans)
if __name__ == '__main__':
main()
| 22 | 22 | 492 | 483 | def main():
numbers = int(eval(input()))
array = [int(x) for x in input().split()]
maximum = 1000001
counter = [0] * maximum
for x in array:
if counter[x] != 0:
counter[x] = 2
continue
else:
for multiple in range(x, maximum, x):
counter[multiple] += 1
ans = 0
for x in array:
if counter[x] == 1:
ans += 1
print(ans)
if __name__ == "__main__":
main()
| def main():
eval(input())
array = sorted(int(x) for x in input().split())
maximum = 1000001
counter = [0] * maximum
for x in array:
if counter[x] != 0:
counter[x] = 2
continue
else:
for multiple in range(x, maximum, x):
counter[multiple] += 1
ans = 0
for x in array:
if counter[x] == 1:
ans += 1
print(ans)
if __name__ == "__main__":
main()
| false | 0 | [
"- numbers = int(eval(input()))",
"- array = [int(x) for x in input().split()]",
"+ eval(input())",
"+ array = sorted(int(x) for x in input().split())"
]
| false | 0.200758 | 0.179509 | 1.118369 | [
"s753754029",
"s741619275"
]
|
u669382434 | p03818 | python | s691837245 | s455008351 | 91 | 70 | 14,396 | 14,396 | Accepted | Accepted | 23.08 | n=int(eval(input()))
a=list(map(int,input().split()))
a.sort()
kjn=0
mi2=0
mi=0
for i in range(0,n):
if a[i]==kjn:
mi2=1-mi2
else:
kjn=a[i]
mi+=1
print((mi-mi2)) | n=int(eval(input()))
a=list(map(int,input().split()))
sn=[0]*100001
mi2=0
mi=0
for i in range(0,n):
if sn[a[i]]==1:
mi2=1-mi2
else:
sn[a[i]]=1
mi+=1
print((mi-mi2)) | 13 | 12 | 197 | 199 | n = int(eval(input()))
a = list(map(int, input().split()))
a.sort()
kjn = 0
mi2 = 0
mi = 0
for i in range(0, n):
if a[i] == kjn:
mi2 = 1 - mi2
else:
kjn = a[i]
mi += 1
print((mi - mi2))
| n = int(eval(input()))
a = list(map(int, input().split()))
sn = [0] * 100001
mi2 = 0
mi = 0
for i in range(0, n):
if sn[a[i]] == 1:
mi2 = 1 - mi2
else:
sn[a[i]] = 1
mi += 1
print((mi - mi2))
| false | 7.692308 | [
"-a.sort()",
"-kjn = 0",
"+sn = [0] * 100001",
"- if a[i] == kjn:",
"+ if sn[a[i]] == 1:",
"- kjn = a[i]",
"+ sn[a[i]] = 1"
]
| false | 0.147782 | 0.045249 | 3.265952 | [
"s691837245",
"s455008351"
]
|
u374146618 | p03076 | python | s072802599 | s320700606 | 149 | 17 | 14,208 | 2,940 | Accepted | Accepted | 88.59 | import numpy as np
a = np.array([int(eval(input())) for _ in range(5)])
aa = np.array(list([-(-x//10*10) for x in a]))
b = aa-a
ans = sum(aa)-max(b)
print(ans) | a = [int(eval(input())) for _ in range(5)]
aa = [-(-x//10*10) for x in a]
b = [x-y for x, y in zip(aa, a)]
ans = sum(aa)-max(b)
print(ans) | 7 | 5 | 165 | 136 | import numpy as np
a = np.array([int(eval(input())) for _ in range(5)])
aa = np.array(list([-(-x // 10 * 10) for x in a]))
b = aa - a
ans = sum(aa) - max(b)
print(ans)
| a = [int(eval(input())) for _ in range(5)]
aa = [-(-x // 10 * 10) for x in a]
b = [x - y for x, y in zip(aa, a)]
ans = sum(aa) - max(b)
print(ans)
| false | 28.571429 | [
"-import numpy as np",
"-",
"-a = np.array([int(eval(input())) for _ in range(5)])",
"-aa = np.array(list([-(-x // 10 * 10) for x in a]))",
"-b = aa - a",
"+a = [int(eval(input())) for _ in range(5)]",
"+aa = [-(-x // 10 * 10) for x in a]",
"+b = [x - y for x, y in zip(aa, a)]"
]
| false | 0.185244 | 0.057009 | 3.249403 | [
"s072802599",
"s320700606"
]
|
u528470578 | p03478 | python | s482561504 | s052025605 | 39 | 27 | 3,060 | 3,060 | Accepted | Accepted | 30.77 | N, A, B = list(map(int, input().split()))
ans = 0
for i in range(1, N+1):
si = list(str(i))
isum = sum(int(k) for k in si)
if A <= isum <= B:
ans += i
print(ans) | N, A, B = list(map(int, input().split()))
def solve(n):
if n == 0:
return 0
else:
temp = n % 10
return temp + solve(n // 10)
ans = 0
for i in range(1, N+1):
if A <= solve(i) <= B:
ans += i
print(ans) | 8 | 14 | 182 | 252 | N, A, B = list(map(int, input().split()))
ans = 0
for i in range(1, N + 1):
si = list(str(i))
isum = sum(int(k) for k in si)
if A <= isum <= B:
ans += i
print(ans)
| N, A, B = list(map(int, input().split()))
def solve(n):
if n == 0:
return 0
else:
temp = n % 10
return temp + solve(n // 10)
ans = 0
for i in range(1, N + 1):
if A <= solve(i) <= B:
ans += i
print(ans)
| false | 42.857143 | [
"+",
"+",
"+def solve(n):",
"+ if n == 0:",
"+ return 0",
"+ else:",
"+ temp = n % 10",
"+ return temp + solve(n // 10)",
"+",
"+",
"- si = list(str(i))",
"- isum = sum(int(k) for k in si)",
"- if A <= isum <= B:",
"+ if A <= solve(i) <= B:"
]
| false | 0.03701 | 0.036437 | 1.015718 | [
"s482561504",
"s052025605"
]
|
u375193358 | p02628 | python | s107236418 | s900265431 | 30 | 24 | 9,196 | 9,124 | Accepted | Accepted | 20 | N, K = list(map(int,input().split()))
p = list(map(int,input().split()))
p.sort()
ans = 0
for i in range(K):
ans += p[i]
print(ans) | N, K = list(map(int,input().split()))
p = list(map(int,input().split()))
p.sort()
print((sum(p[:K]))) | 8 | 4 | 137 | 96 | N, K = list(map(int, input().split()))
p = list(map(int, input().split()))
p.sort()
ans = 0
for i in range(K):
ans += p[i]
print(ans)
| N, K = list(map(int, input().split()))
p = list(map(int, input().split()))
p.sort()
print((sum(p[:K])))
| false | 50 | [
"-ans = 0",
"-for i in range(K):",
"- ans += p[i]",
"-print(ans)",
"+print((sum(p[:K])))"
]
| false | 0.035575 | 0.046011 | 0.773173 | [
"s107236418",
"s900265431"
]
|
u600402037 | p03765 | python | s994102678 | s733585261 | 1,557 | 1,420 | 25,464 | 25,468 | Accepted | Accepted | 8.8 | # coding: utf-8
import sys
import numpy as np
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
S = '-' + sr()
T = '-' + sr()
Q = ir()
cnt_S = np.array([[0, 0] for _ in range(len(S))])
cnt_T = np.array([[0, 0] for _ in range(len(S))])
for i, s in enumerate(S[1:], 1):
if s == 'A':
cnt_S[i][0] = 1
else:
cnt_S[i][1] = 1
for i, t in enumerate(T[1:], 1):
if t == 'A':
cnt_T[i][0] = 1
else:
cnt_T[i][1] = 1
np.add.accumulate(cnt_S, axis=0, out=cnt_S)
np.add.accumulate(cnt_T, axis=0, out=cnt_T)
for _ in range(Q):
a, b, c, d = lr()
num_S = cnt_S[b][0] - cnt_S[b][1] - (cnt_S[a-1][0] - cnt_S[a-1][1])
num_T = cnt_T[d][0] - cnt_T[d][1] - (cnt_T[c-1][0] - cnt_T[c-1][1])
if (num_S - num_T) % 3 == 0:
print('YES')
else:
print('NO')
# 58 | # coding: utf-8
import sys
import numpy as np
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
S = '-' + sr()
T = '-' + sr()
Q = ir()
cnt_S = np.array([[0, 0] for _ in range(len(S))])
cnt_T = np.array([[0, 0] for _ in range(len(S))])
for i, s in enumerate(S[1:], 1):
if s == 'A':
cnt_S[i][0] = 1
else:
cnt_S[i][1] = 1
for i, t in enumerate(T[1:], 1):
if t == 'A':
cnt_T[i][0] = 1
else:
cnt_T[i][1] = 1
np.add.accumulate(cnt_S, axis=0, out=cnt_S)
np.add.accumulate(cnt_T, axis=0, out=cnt_T)
answer = []
for _ in range(Q):
a, b, c, d = lr()
num_S = cnt_S[b][0] - cnt_S[b][1] - (cnt_S[a-1][0] - cnt_S[a-1][1])
num_T = cnt_T[d][0] - cnt_T[d][1] - (cnt_T[c-1][0] - cnt_T[c-1][1])
if (num_S - num_T) % 3 == 0:
answer.append('YES')
else:
answer.append('NO')
print(('\n'.join(answer)))
# 58 | 38 | 40 | 913 | 968 | # coding: utf-8
import sys
import numpy as np
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
S = "-" + sr()
T = "-" + sr()
Q = ir()
cnt_S = np.array([[0, 0] for _ in range(len(S))])
cnt_T = np.array([[0, 0] for _ in range(len(S))])
for i, s in enumerate(S[1:], 1):
if s == "A":
cnt_S[i][0] = 1
else:
cnt_S[i][1] = 1
for i, t in enumerate(T[1:], 1):
if t == "A":
cnt_T[i][0] = 1
else:
cnt_T[i][1] = 1
np.add.accumulate(cnt_S, axis=0, out=cnt_S)
np.add.accumulate(cnt_T, axis=0, out=cnt_T)
for _ in range(Q):
a, b, c, d = lr()
num_S = cnt_S[b][0] - cnt_S[b][1] - (cnt_S[a - 1][0] - cnt_S[a - 1][1])
num_T = cnt_T[d][0] - cnt_T[d][1] - (cnt_T[c - 1][0] - cnt_T[c - 1][1])
if (num_S - num_T) % 3 == 0:
print("YES")
else:
print("NO")
# 58
| # coding: utf-8
import sys
import numpy as np
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
S = "-" + sr()
T = "-" + sr()
Q = ir()
cnt_S = np.array([[0, 0] for _ in range(len(S))])
cnt_T = np.array([[0, 0] for _ in range(len(S))])
for i, s in enumerate(S[1:], 1):
if s == "A":
cnt_S[i][0] = 1
else:
cnt_S[i][1] = 1
for i, t in enumerate(T[1:], 1):
if t == "A":
cnt_T[i][0] = 1
else:
cnt_T[i][1] = 1
np.add.accumulate(cnt_S, axis=0, out=cnt_S)
np.add.accumulate(cnt_T, axis=0, out=cnt_T)
answer = []
for _ in range(Q):
a, b, c, d = lr()
num_S = cnt_S[b][0] - cnt_S[b][1] - (cnt_S[a - 1][0] - cnt_S[a - 1][1])
num_T = cnt_T[d][0] - cnt_T[d][1] - (cnt_T[c - 1][0] - cnt_T[c - 1][1])
if (num_S - num_T) % 3 == 0:
answer.append("YES")
else:
answer.append("NO")
print(("\n".join(answer)))
# 58
| false | 5 | [
"+answer = []",
"- print(\"YES\")",
"+ answer.append(\"YES\")",
"- print(\"NO\")",
"+ answer.append(\"NO\")",
"+print((\"\\n\".join(answer)))"
]
| false | 0.361461 | 0.235694 | 1.533603 | [
"s994102678",
"s733585261"
]
|
u588341295 | p03579 | python | s726129988 | s796398011 | 477 | 355 | 31,876 | 31,212 | Accepted | Accepted | 25.58 | # -*- coding: utf-8 -*-
import sys
from collections import Counter
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7
N,M=MAP()
nodes=[[] for i in range(N)]
for i in range(M):
a,b=MAP()
nodes[a-1].append(b-1)
nodes[b-1].append(a-1)
visited=[False]*N
team=['']*N
def rec(u):
if visited[u]:
return True
visited[u]=True
for v in nodes[u]:
if team[u]==team[v]:
return False
if team[u]=='a':
team[v]='b'
elif team[u]=='b':
team[v]='a'
if not rec(v):
return False
return True
# 1からnまでの等差数列の和
def get_sum(n):
return (1+n)*n//2
team[0]='a'
if rec(0):
C=Counter(team)
ans=C['a']*C['b']-M
else:
ans=get_sum(N-1)-M
print(ans)
| # -*- coding: utf-8 -*-
import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7
N, M = MAP()
nodes = tuple([] for i in range(N))
for i in range(M):
a, b = MAP()
a -= 1
b -= 1
nodes[a].append(b)
nodes[b].append(a)
# 二部グラフ判定
color = [-1] * N
def rec(u, prev, c):
if color[u] == -1:
color[u] = c
else:
if color[u] == c:
return True
else:
return False
for v in nodes[u]:
if v != prev:
if not rec(v, u, 1-c):
return False
return True
if rec(0, -1, 0):
a = sum(color)
b = N - a
ans = a*b - M
else:
ans = N*(N-1) // 2 - M
print(ans)
| 56 | 52 | 1,269 | 1,316 | # -*- coding: utf-8 -*-
import sys
from collections import Counter
def input():
return sys.stdin.readline().strip()
def list2d(a, b, c):
return [[c] * b for i in range(a)]
def list3d(a, b, c, d):
return [[[d] * c for j in range(b)] for i in range(a)]
def ceil(x, y=1):
return int(-(-x // y))
def INT():
return int(eval(input()))
def MAP():
return list(map(int, input().split()))
def LIST():
return list(map(int, input().split()))
def Yes():
print("Yes")
def No():
print("No")
def YES():
print("YES")
def NO():
print("NO")
sys.setrecursionlimit(10**9)
INF = float("inf")
MOD = 10**9 + 7
N, M = MAP()
nodes = [[] for i in range(N)]
for i in range(M):
a, b = MAP()
nodes[a - 1].append(b - 1)
nodes[b - 1].append(a - 1)
visited = [False] * N
team = [""] * N
def rec(u):
if visited[u]:
return True
visited[u] = True
for v in nodes[u]:
if team[u] == team[v]:
return False
if team[u] == "a":
team[v] = "b"
elif team[u] == "b":
team[v] = "a"
if not rec(v):
return False
return True
# 1からnまでの等差数列の和
def get_sum(n):
return (1 + n) * n // 2
team[0] = "a"
if rec(0):
C = Counter(team)
ans = C["a"] * C["b"] - M
else:
ans = get_sum(N - 1) - M
print(ans)
| # -*- coding: utf-8 -*-
import sys
def input():
return sys.stdin.readline().strip()
def list2d(a, b, c):
return [[c] * b for i in range(a)]
def list3d(a, b, c, d):
return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e):
return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1):
return int(-(-x // y))
def INT():
return int(eval(input()))
def MAP():
return list(map(int, input().split()))
def LIST(N=None):
return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes():
print("Yes")
def No():
print("No")
def YES():
print("YES")
def NO():
print("NO")
sys.setrecursionlimit(10**9)
INF = float("inf")
MOD = 10**9 + 7
N, M = MAP()
nodes = tuple([] for i in range(N))
for i in range(M):
a, b = MAP()
a -= 1
b -= 1
nodes[a].append(b)
nodes[b].append(a)
# 二部グラフ判定
color = [-1] * N
def rec(u, prev, c):
if color[u] == -1:
color[u] = c
else:
if color[u] == c:
return True
else:
return False
for v in nodes[u]:
if v != prev:
if not rec(v, u, 1 - c):
return False
return True
if rec(0, -1, 0):
a = sum(color)
b = N - a
ans = a * b - M
else:
ans = N * (N - 1) // 2 - M
print(ans)
| false | 7.142857 | [
"-from collections import Counter",
"+def list4d(a, b, c, d, e):",
"+ return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]",
"+",
"+",
"-def LIST():",
"- return list(map(int, input().split()))",
"+def LIST(N=None):",
"+ return list(MAP()) if N is None else [INT() for i in range(N)]",
"-nodes = [[] for i in range(N)]",
"+nodes = tuple([] for i in range(N))",
"- nodes[a - 1].append(b - 1)",
"- nodes[b - 1].append(a - 1)",
"-visited = [False] * N",
"-team = [\"\"] * N",
"+ a -= 1",
"+ b -= 1",
"+ nodes[a].append(b)",
"+ nodes[b].append(a)",
"+# 二部グラフ判定",
"+color = [-1] * N",
"-def rec(u):",
"- if visited[u]:",
"- return True",
"- visited[u] = True",
"+def rec(u, prev, c):",
"+ if color[u] == -1:",
"+ color[u] = c",
"+ else:",
"+ if color[u] == c:",
"+ return True",
"+ else:",
"+ return False",
"- if team[u] == team[v]:",
"- return False",
"- if team[u] == \"a\":",
"- team[v] = \"b\"",
"- elif team[u] == \"b\":",
"- team[v] = \"a\"",
"- if not rec(v):",
"- return False",
"+ if v != prev:",
"+ if not rec(v, u, 1 - c):",
"+ return False",
"-# 1からnまでの等差数列の和",
"-def get_sum(n):",
"- return (1 + n) * n // 2",
"-",
"-",
"-team[0] = \"a\"",
"-if rec(0):",
"- C = Counter(team)",
"- ans = C[\"a\"] * C[\"b\"] - M",
"+if rec(0, -1, 0):",
"+ a = sum(color)",
"+ b = N - a",
"+ ans = a * b - M",
"- ans = get_sum(N - 1) - M",
"+ ans = N * (N - 1) // 2 - M"
]
| false | 0.063942 | 0.037746 | 1.694004 | [
"s726129988",
"s796398011"
]
|
u629540524 | p03079 | python | s167295693 | s558277164 | 61 | 29 | 61,692 | 9,028 | Accepted | Accepted | 52.46 | a,b,c = input().split()
if a==b==c:
print('Yes')
else:
print('No') | a=input().split()
if len(set(a))==1:
print('Yes')
else:
print('No') | 5 | 5 | 78 | 79 | a, b, c = input().split()
if a == b == c:
print("Yes")
else:
print("No")
| a = input().split()
if len(set(a)) == 1:
print("Yes")
else:
print("No")
| false | 0 | [
"-a, b, c = input().split()",
"-if a == b == c:",
"+a = input().split()",
"+if len(set(a)) == 1:"
]
| false | 0.047302 | 0.041739 | 1.133291 | [
"s167295693",
"s558277164"
]
|
u814781830 | p02790 | python | s996706476 | s438937781 | 164 | 17 | 38,256 | 2,940 | Accepted | Accepted | 89.63 | a, b = input().split()
atxt = ''.join([a for _ in range(int(b))])
btxt = ''.join([b for _ in range(int(a))])
if atxt <= btxt:
print(atxt)
else:
print(btxt)
| a, b = input().split()
atxt, btxt = "", ""
for i in range(int(b)):
atxt += a
for i in range(int(a)):
btxt += b
if atxt <= btxt:
print(atxt)
else:
print(btxt)
| 9 | 10 | 178 | 175 | a, b = input().split()
atxt = "".join([a for _ in range(int(b))])
btxt = "".join([b for _ in range(int(a))])
if atxt <= btxt:
print(atxt)
else:
print(btxt)
| a, b = input().split()
atxt, btxt = "", ""
for i in range(int(b)):
atxt += a
for i in range(int(a)):
btxt += b
if atxt <= btxt:
print(atxt)
else:
print(btxt)
| false | 10 | [
"-atxt = \"\".join([a for _ in range(int(b))])",
"-btxt = \"\".join([b for _ in range(int(a))])",
"+atxt, btxt = \"\", \"\"",
"+for i in range(int(b)):",
"+ atxt += a",
"+for i in range(int(a)):",
"+ btxt += b"
]
| false | 0.092476 | 0.007731 | 11.962015 | [
"s996706476",
"s438937781"
]
|
u525065967 | p02596 | python | s310184575 | s951891329 | 187 | 127 | 9,116 | 9,168 | Accepted | Accepted | 32.09 | k = int(eval(input()))
r = 0
for i in range(1, k+1):
r = (r*10 + 7)%k
if r == 0:
print(i)
exit()
print((-1))
| def f(k):
r = 7%k
for i in range(k):
if r == 0: return i+1
r = (r*10 + 7)%k
return -1
print((f(int(eval(input())))))
| 8 | 8 | 132 | 145 | k = int(eval(input()))
r = 0
for i in range(1, k + 1):
r = (r * 10 + 7) % k
if r == 0:
print(i)
exit()
print((-1))
| def f(k):
r = 7 % k
for i in range(k):
if r == 0:
return i + 1
r = (r * 10 + 7) % k
return -1
print((f(int(eval(input())))))
| false | 0 | [
"-k = int(eval(input()))",
"-r = 0",
"-for i in range(1, k + 1):",
"- r = (r * 10 + 7) % k",
"- if r == 0:",
"- print(i)",
"- exit()",
"-print((-1))",
"+def f(k):",
"+ r = 7 % k",
"+ for i in range(k):",
"+ if r == 0:",
"+ return i + 1",
"+ r = (r * 10 + 7) % k",
"+ return -1",
"+",
"+",
"+print((f(int(eval(input())))))"
]
| false | 0.065189 | 0.074237 | 0.87812 | [
"s310184575",
"s951891329"
]
|
u095426154 | p03804 | python | s287284599 | s683786944 | 147 | 73 | 3,064 | 69,072 | Accepted | Accepted | 50.34 | N,M = list(map(int,input().split()))
A=[]
B=[]
for i in range(N):
A.append(list(eval(input())))
for i in range(M):
B.append(list(eval(input())))
k=N-M+1
ans=False
for i in range(k):
for j in range(k):
flg=True
for p in range(M):
for q in range(M):
if A[i+p][j+q] != B[p][q]:
flg=False
ans=flg
if ans:
break
if ans:
break
if ans:
print("Yes")
else:
print("No") | # coding: utf-8
N,M=list(map(int,input().split()))
picN=[]
picM=[]
for i in range(N):
L=list(eval(input()))
picN.append(L)
for i in range(M):
L=list(eval(input()))
picM.append(L)
K=N-M
for i in range(K+1):
for j in range(K+1):
flg=True
for a in range(M):
for b in range(M):
if picN[a+i][b+j]!=picM[a][b]:
flg=False
if flg:
break
if flg:
break
if flg:
print("Yes")
else:
print("No") | 33 | 31 | 537 | 522 | N, M = list(map(int, input().split()))
A = []
B = []
for i in range(N):
A.append(list(eval(input())))
for i in range(M):
B.append(list(eval(input())))
k = N - M + 1
ans = False
for i in range(k):
for j in range(k):
flg = True
for p in range(M):
for q in range(M):
if A[i + p][j + q] != B[p][q]:
flg = False
ans = flg
if ans:
break
if ans:
break
if ans:
print("Yes")
else:
print("No")
| # coding: utf-8
N, M = list(map(int, input().split()))
picN = []
picM = []
for i in range(N):
L = list(eval(input()))
picN.append(L)
for i in range(M):
L = list(eval(input()))
picM.append(L)
K = N - M
for i in range(K + 1):
for j in range(K + 1):
flg = True
for a in range(M):
for b in range(M):
if picN[a + i][b + j] != picM[a][b]:
flg = False
if flg:
break
if flg:
break
if flg:
print("Yes")
else:
print("No")
| false | 6.060606 | [
"+# coding: utf-8",
"-A = []",
"-B = []",
"+picN = []",
"+picM = []",
"- A.append(list(eval(input())))",
"+ L = list(eval(input()))",
"+ picN.append(L)",
"- B.append(list(eval(input())))",
"-k = N - M + 1",
"-ans = False",
"-for i in range(k):",
"- for j in range(k):",
"+ L = list(eval(input()))",
"+ picM.append(L)",
"+K = N - M",
"+for i in range(K + 1):",
"+ for j in range(K + 1):",
"- for p in range(M):",
"- for q in range(M):",
"- if A[i + p][j + q] != B[p][q]:",
"+ for a in range(M):",
"+ for b in range(M):",
"+ if picN[a + i][b + j] != picM[a][b]:",
"- ans = flg",
"- if ans:",
"+ if flg:",
"- if ans:",
"+ if flg:",
"-if ans:",
"+if flg:"
]
| false | 0.067092 | 0.053406 | 1.256257 | [
"s287284599",
"s683786944"
]
|
u869519920 | p03061 | python | s914428924 | s703720113 | 129 | 96 | 24,888 | 24,976 | Accepted | Accepted | 25.58 | import math
import itertools
n = int(eval(input()))
a = list(map(int, input().split()))
pf = [0]*(n+1)
pb = [0]*(n+1)
p = a[0]
for i in range(n):
p = math.gcd(p, a[i])
pf[i+1] = p
p = a[-1]
for i in range(-1, -n-1, -1):
p = math.gcd(p, a[i])
pb[i-1] = p
ans = [0]*n
for i in range(n):
ans[i] = math.gcd(pf[i], pb[i+1])
print((max(ans))) | import math
import itertools
n = int(eval(input()))
a = list(map(int, input().split()))
pf = [0] + list(itertools.accumulate(a, math.gcd))
pb = [0] + list(itertools.accumulate(reversed(a), math.gcd))
pb.reverse()
ans = [0]*n
for i in range(n):
ans[i] = math.gcd(pf[i], pb[i+1])
print((max(ans))) | 19 | 12 | 357 | 301 | import math
import itertools
n = int(eval(input()))
a = list(map(int, input().split()))
pf = [0] * (n + 1)
pb = [0] * (n + 1)
p = a[0]
for i in range(n):
p = math.gcd(p, a[i])
pf[i + 1] = p
p = a[-1]
for i in range(-1, -n - 1, -1):
p = math.gcd(p, a[i])
pb[i - 1] = p
ans = [0] * n
for i in range(n):
ans[i] = math.gcd(pf[i], pb[i + 1])
print((max(ans)))
| import math
import itertools
n = int(eval(input()))
a = list(map(int, input().split()))
pf = [0] + list(itertools.accumulate(a, math.gcd))
pb = [0] + list(itertools.accumulate(reversed(a), math.gcd))
pb.reverse()
ans = [0] * n
for i in range(n):
ans[i] = math.gcd(pf[i], pb[i + 1])
print((max(ans)))
| false | 36.842105 | [
"-pf = [0] * (n + 1)",
"-pb = [0] * (n + 1)",
"-p = a[0]",
"-for i in range(n):",
"- p = math.gcd(p, a[i])",
"- pf[i + 1] = p",
"-p = a[-1]",
"-for i in range(-1, -n - 1, -1):",
"- p = math.gcd(p, a[i])",
"- pb[i - 1] = p",
"+pf = [0] + list(itertools.accumulate(a, math.gcd))",
"+pb = [0] + list(itertools.accumulate(reversed(a), math.gcd))",
"+pb.reverse()"
]
| false | 0.038487 | 0.039404 | 0.976715 | [
"s914428924",
"s703720113"
]
|
u197300260 | p03610 | python | s970380894 | s416647096 | 30 | 22 | 3,572 | 3,700 | Accepted | Accepted | 26.67 | # Problem https://atcoder.jp/contests/abc072/tasks/abc072_b
# Python 2nd Try
class Problem:
def __init__(self, problemstring):
self.problemstring = problemstring
self.length = len(self.problemstring)
def solve(self):
result = ''
resultlist = []
for j in range(0, self.length):
if j % 2 == 0:
resultlist.append(self.problemstring[j])
result = ''.join(resultlist)
return result
if __name__ == "__main__":
# S = "atcoder"
# print("{} => {}".format(S, Problem(S).solve()))
# S = "aaaa"
# print("{} => {}".format(S, Problem(S).solve()))
# S = "z"
# print("{} => {}".format(S, Problem(S).solve()))
S = eval(input())
print((Problem(S).solve())) | # Problem https://atcoder.jp/contests/abc072/tasks/abc072_b
# Python 3rd Try
import copy
class Problem:
def __init__(self, inputstring):
self.inputstring = inputstring
def __str__(self):
return self.inputstring
def solver(self):
result = ''
string = copy.copy(self.inputstring)
result = string[0:len(string):2]
return result
if __name__ == "__main__":
s = eval(input())
x = Problem(s)
print((x.solver()))
| 28 | 23 | 779 | 497 | # Problem https://atcoder.jp/contests/abc072/tasks/abc072_b
# Python 2nd Try
class Problem:
def __init__(self, problemstring):
self.problemstring = problemstring
self.length = len(self.problemstring)
def solve(self):
result = ""
resultlist = []
for j in range(0, self.length):
if j % 2 == 0:
resultlist.append(self.problemstring[j])
result = "".join(resultlist)
return result
if __name__ == "__main__":
# S = "atcoder"
# print("{} => {}".format(S, Problem(S).solve()))
# S = "aaaa"
# print("{} => {}".format(S, Problem(S).solve()))
# S = "z"
# print("{} => {}".format(S, Problem(S).solve()))
S = eval(input())
print((Problem(S).solve()))
| # Problem https://atcoder.jp/contests/abc072/tasks/abc072_b
# Python 3rd Try
import copy
class Problem:
def __init__(self, inputstring):
self.inputstring = inputstring
def __str__(self):
return self.inputstring
def solver(self):
result = ""
string = copy.copy(self.inputstring)
result = string[0 : len(string) : 2]
return result
if __name__ == "__main__":
s = eval(input())
x = Problem(s)
print((x.solver()))
| false | 17.857143 | [
"-# Python 2nd Try",
"+# Python 3rd Try",
"+import copy",
"+",
"+",
"- def __init__(self, problemstring):",
"- self.problemstring = problemstring",
"- self.length = len(self.problemstring)",
"+ def __init__(self, inputstring):",
"+ self.inputstring = inputstring",
"- def solve(self):",
"+ def __str__(self):",
"+ return self.inputstring",
"+",
"+ def solver(self):",
"- resultlist = []",
"- for j in range(0, self.length):",
"- if j % 2 == 0:",
"- resultlist.append(self.problemstring[j])",
"- result = \"\".join(resultlist)",
"+ string = copy.copy(self.inputstring)",
"+ result = string[0 : len(string) : 2]",
"- # S = \"atcoder\"",
"- # print(\"{} => {}\".format(S, Problem(S).solve()))",
"- # S = \"aaaa\"",
"- # print(\"{} => {}\".format(S, Problem(S).solve()))",
"- # S = \"z\"",
"- # print(\"{} => {}\".format(S, Problem(S).solve()))",
"- S = eval(input())",
"- print((Problem(S).solve()))",
"+ s = eval(input())",
"+ x = Problem(s)",
"+ print((x.solver()))"
]
| false | 0.044958 | 0.039135 | 1.148802 | [
"s970380894",
"s416647096"
]
|
u685263709 | p03088 | python | s886336875 | s872530075 | 325 | 280 | 53,616 | 47,320 | Accepted | Accepted | 13.85 | N = int(eval(input()))
mod = 10 ** 9 + 7
dp = [[[[0 for _ in range(4)] for _ in range(4)] for _ in range(4)] for _ in range(N+1)]
def ng(a: int, b: int, c: int):
return (a == 1 and b == 2 and c == 3)
# 初期状態の直近3文字はTTTであると見なして良い
dp[0][0][0][0] = 1
for i in range(N):
for a in range(4):
for b in range(4):
for c in range(4):
for d in range(4):
# 3文字パターン
if (ng(b, c, d) or ng(c, b, d) or ng(b, d, c)):
continue
# 4文字パターン
if ng(a, c, d) or ng(a, b, d):
continue
# NGパターンがなければ遷移先に足す
dp[i+1][b][c][d] = (dp[i][a][b][c] + dp[i+1][b][c][d]) % mod
ans = 0
for a in range(4):
for b in range(4):
for c in range(4):
ans += dp[N][a][b][c] % mod
print((ans % mod))
| N = int(eval(input()))
mod = 10 ** 9 + 7
memo = [{} for i in range(N+1)]
def ok(last4):
for i in range(4):
t = list(last4)
if i >= 1:
t[i-1], t[i] = t[i], t[i-1]
if ''.join(t).count('AGC') >= 1:
return False
return True
def dfs(cur, last3):
if last3 in memo[cur]:
return memo[cur][last3]
if cur == N:
return 1
ret = 0
for c in 'ATCG':
if ok(last3 + c):
ret = (ret + dfs(cur + 1, last3[1:]+c)) % mod
memo[cur][last3] = ret
#print(memo, cur)
return ret
print((dfs(0, 'TTT'))) | 34 | 31 | 920 | 622 | N = int(eval(input()))
mod = 10**9 + 7
dp = [
[[[0 for _ in range(4)] for _ in range(4)] for _ in range(4)] for _ in range(N + 1)
]
def ng(a: int, b: int, c: int):
return a == 1 and b == 2 and c == 3
# 初期状態の直近3文字はTTTであると見なして良い
dp[0][0][0][0] = 1
for i in range(N):
for a in range(4):
for b in range(4):
for c in range(4):
for d in range(4):
# 3文字パターン
if ng(b, c, d) or ng(c, b, d) or ng(b, d, c):
continue
# 4文字パターン
if ng(a, c, d) or ng(a, b, d):
continue
# NGパターンがなければ遷移先に足す
dp[i + 1][b][c][d] = (dp[i][a][b][c] + dp[i + 1][b][c][d]) % mod
ans = 0
for a in range(4):
for b in range(4):
for c in range(4):
ans += dp[N][a][b][c] % mod
print((ans % mod))
| N = int(eval(input()))
mod = 10**9 + 7
memo = [{} for i in range(N + 1)]
def ok(last4):
for i in range(4):
t = list(last4)
if i >= 1:
t[i - 1], t[i] = t[i], t[i - 1]
if "".join(t).count("AGC") >= 1:
return False
return True
def dfs(cur, last3):
if last3 in memo[cur]:
return memo[cur][last3]
if cur == N:
return 1
ret = 0
for c in "ATCG":
if ok(last3 + c):
ret = (ret + dfs(cur + 1, last3[1:] + c)) % mod
memo[cur][last3] = ret
# print(memo, cur)
return ret
print((dfs(0, "TTT")))
| false | 8.823529 | [
"-dp = [",
"- [[[0 for _ in range(4)] for _ in range(4)] for _ in range(4)] for _ in range(N + 1)",
"-]",
"+memo = [{} for i in range(N + 1)]",
"-def ng(a: int, b: int, c: int):",
"- return a == 1 and b == 2 and c == 3",
"+def ok(last4):",
"+ for i in range(4):",
"+ t = list(last4)",
"+ if i >= 1:",
"+ t[i - 1], t[i] = t[i], t[i - 1]",
"+ if \"\".join(t).count(\"AGC\") >= 1:",
"+ return False",
"+ return True",
"-# 初期状態の直近3文字はTTTであると見なして良い",
"-dp[0][0][0][0] = 1",
"-for i in range(N):",
"- for a in range(4):",
"- for b in range(4):",
"- for c in range(4):",
"- for d in range(4):",
"- # 3文字パターン",
"- if ng(b, c, d) or ng(c, b, d) or ng(b, d, c):",
"- continue",
"- # 4文字パターン",
"- if ng(a, c, d) or ng(a, b, d):",
"- continue",
"- # NGパターンがなければ遷移先に足す",
"- dp[i + 1][b][c][d] = (dp[i][a][b][c] + dp[i + 1][b][c][d]) % mod",
"-ans = 0",
"-for a in range(4):",
"- for b in range(4):",
"- for c in range(4):",
"- ans += dp[N][a][b][c] % mod",
"-print((ans % mod))",
"+def dfs(cur, last3):",
"+ if last3 in memo[cur]:",
"+ return memo[cur][last3]",
"+ if cur == N:",
"+ return 1",
"+ ret = 0",
"+ for c in \"ATCG\":",
"+ if ok(last3 + c):",
"+ ret = (ret + dfs(cur + 1, last3[1:] + c)) % mod",
"+ memo[cur][last3] = ret",
"+ # print(memo, cur)",
"+ return ret",
"+",
"+",
"+print((dfs(0, \"TTT\")))"
]
| false | 0.064579 | 0.074555 | 0.86619 | [
"s886336875",
"s872530075"
]
|
u844789719 | p03329 | python | s902628823 | s186557615 | 287 | 204 | 3,828 | 3,864 | Accepted | Accepted | 28.92 | import itertools
N = int(eval(input()))
base = [1]
for i in range(1, 7):
if 6 ** i <= N:
base.append(6 ** i)
for i in range(1, 6):
if 9 ** i <= N:
base.append(9 ** i)
ans = N
dp = [0] * (N + 1)
for i in range(1, N + 1):
dp[i] = min([dp[i - j] + 1 if i - j >= 0 else j for j in base])
print((dp[N])) | N = int(eval(input()))
def base_n(x, n):
results = 0
while x > 0:
results += x % n
x //= n
return results
print((min([base_n(i, 6) + base_n(N - i, 9) for i in range(N + 1)]))) | 16 | 10 | 335 | 206 | import itertools
N = int(eval(input()))
base = [1]
for i in range(1, 7):
if 6**i <= N:
base.append(6**i)
for i in range(1, 6):
if 9**i <= N:
base.append(9**i)
ans = N
dp = [0] * (N + 1)
for i in range(1, N + 1):
dp[i] = min([dp[i - j] + 1 if i - j >= 0 else j for j in base])
print((dp[N]))
| N = int(eval(input()))
def base_n(x, n):
results = 0
while x > 0:
results += x % n
x //= n
return results
print((min([base_n(i, 6) + base_n(N - i, 9) for i in range(N + 1)])))
| false | 37.5 | [
"-import itertools",
"+N = int(eval(input()))",
"-N = int(eval(input()))",
"-base = [1]",
"-for i in range(1, 7):",
"- if 6**i <= N:",
"- base.append(6**i)",
"-for i in range(1, 6):",
"- if 9**i <= N:",
"- base.append(9**i)",
"-ans = N",
"-dp = [0] * (N + 1)",
"-for i in range(1, N + 1):",
"- dp[i] = min([dp[i - j] + 1 if i - j >= 0 else j for j in base])",
"-print((dp[N]))",
"+",
"+def base_n(x, n):",
"+ results = 0",
"+ while x > 0:",
"+ results += x % n",
"+ x //= n",
"+ return results",
"+",
"+",
"+print((min([base_n(i, 6) + base_n(N - i, 9) for i in range(N + 1)])))"
]
| false | 0.06142 | 0.051362 | 1.195811 | [
"s902628823",
"s186557615"
]
|
u564902833 | p03112 | python | s009780734 | s512394688 | 1,633 | 1,134 | 12,084 | 16,128 | Accepted | Accepted | 30.56 | import bisect
A, B, Q = list(map(int, input().split()))
INF = 10 ** 18
s = [-INF]
t = [-INF]
for _ in range(A):
s.append(int(eval(input())))
s.append(INF)
for _ in range(B):
t.append(int(eval(input())))
t.append(INF)
for q in range(Q):
x = int(eval(input()))
i, j = bisect.bisect_right(s, x), bisect.bisect_right(t, x)
ans = min(
max(abs(s[i] - x), abs(t[j] - x)),
max(abs(s[i - 1] - x), abs(t[j - 1] - x)),
2 * min(abs(s[i] - x), abs(t[j - 1] - x)) + max(abs(s[i] - x), abs(t[j - 1] - x)),
2 * min(abs(s[i - 1] - x), abs(t[j] - x)) + max(abs(s[i - 1] - x), abs(t[j] - x))
)
print(ans)
| from bisect import bisect_right
A, B, Q = list(map(int, input().split()))
INF = 10 ** 18
s = [-INF] + [int(eval(input())) for i in range(A)] + [INF]
t = [-INF] + [int(eval(input())) for i in range(B)] + [INF]
xs = [int(eval(input())) for i in range(Q)]
for x in xs:
b, d = bisect_right(s, x), bisect_right(t, x)
res = INF
for S in [s[b - 1], s[b]]:
for T in [t[d - 1], t[d]]:
d1, d2 = abs(S - x) + abs(T - S), abs(T - x) + abs(S - T)
res = min(res, d1, d2)
print(res)
| 21 | 14 | 642 | 505 | import bisect
A, B, Q = list(map(int, input().split()))
INF = 10**18
s = [-INF]
t = [-INF]
for _ in range(A):
s.append(int(eval(input())))
s.append(INF)
for _ in range(B):
t.append(int(eval(input())))
t.append(INF)
for q in range(Q):
x = int(eval(input()))
i, j = bisect.bisect_right(s, x), bisect.bisect_right(t, x)
ans = min(
max(abs(s[i] - x), abs(t[j] - x)),
max(abs(s[i - 1] - x), abs(t[j - 1] - x)),
2 * min(abs(s[i] - x), abs(t[j - 1] - x))
+ max(abs(s[i] - x), abs(t[j - 1] - x)),
2 * min(abs(s[i - 1] - x), abs(t[j] - x))
+ max(abs(s[i - 1] - x), abs(t[j] - x)),
)
print(ans)
| from bisect import bisect_right
A, B, Q = list(map(int, input().split()))
INF = 10**18
s = [-INF] + [int(eval(input())) for i in range(A)] + [INF]
t = [-INF] + [int(eval(input())) for i in range(B)] + [INF]
xs = [int(eval(input())) for i in range(Q)]
for x in xs:
b, d = bisect_right(s, x), bisect_right(t, x)
res = INF
for S in [s[b - 1], s[b]]:
for T in [t[d - 1], t[d]]:
d1, d2 = abs(S - x) + abs(T - S), abs(T - x) + abs(S - T)
res = min(res, d1, d2)
print(res)
| false | 33.333333 | [
"-import bisect",
"+from bisect import bisect_right",
"-s = [-INF]",
"-t = [-INF]",
"-for _ in range(A):",
"- s.append(int(eval(input())))",
"-s.append(INF)",
"-for _ in range(B):",
"- t.append(int(eval(input())))",
"-t.append(INF)",
"-for q in range(Q):",
"- x = int(eval(input()))",
"- i, j = bisect.bisect_right(s, x), bisect.bisect_right(t, x)",
"- ans = min(",
"- max(abs(s[i] - x), abs(t[j] - x)),",
"- max(abs(s[i - 1] - x), abs(t[j - 1] - x)),",
"- 2 * min(abs(s[i] - x), abs(t[j - 1] - x))",
"- + max(abs(s[i] - x), abs(t[j - 1] - x)),",
"- 2 * min(abs(s[i - 1] - x), abs(t[j] - x))",
"- + max(abs(s[i - 1] - x), abs(t[j] - x)),",
"- )",
"- print(ans)",
"+s = [-INF] + [int(eval(input())) for i in range(A)] + [INF]",
"+t = [-INF] + [int(eval(input())) for i in range(B)] + [INF]",
"+xs = [int(eval(input())) for i in range(Q)]",
"+for x in xs:",
"+ b, d = bisect_right(s, x), bisect_right(t, x)",
"+ res = INF",
"+ for S in [s[b - 1], s[b]]:",
"+ for T in [t[d - 1], t[d]]:",
"+ d1, d2 = abs(S - x) + abs(T - S), abs(T - x) + abs(S - T)",
"+ res = min(res, d1, d2)",
"+ print(res)"
]
| false | 0.038802 | 0.113833 | 0.34087 | [
"s009780734",
"s512394688"
]
|
u353919145 | p03075 | python | s819157183 | s484892242 | 21 | 17 | 3,316 | 3,064 | Accepted | Accepted | 19.05 | v = []
e = ''
for i in range(6):
v.append(int(eval(input())))
for i in range(len(v)) :
for j in range(i+1, len(v)):
if(abs(v[i] - v[j]) > v[-1]):
e = ':('
if e != '':
print(e)
else:
print('Yay!')
| a=int(eval(input()))
b=int(eval(input()))
c=int(eval(input()))
d=int(eval(input()))
e=int(eval(input()))
k=int(eval(input()))
sub=[]
sub.append(b-a)
sub.append(c-a)
sub.append(d-a)
sub.append(e-a)
sub.append(c-b)
sub.append(d-b)
sub.append(e-b)
sub.append(d-c)
sub.append(e-c)
sub.append(e-d)
max=max(sub)
if max<=k:
print('Yay!')
else:
print(':(') | 15 | 22 | 250 | 341 | v = []
e = ""
for i in range(6):
v.append(int(eval(input())))
for i in range(len(v)):
for j in range(i + 1, len(v)):
if abs(v[i] - v[j]) > v[-1]:
e = ":("
if e != "":
print(e)
else:
print("Yay!")
| a = int(eval(input()))
b = int(eval(input()))
c = int(eval(input()))
d = int(eval(input()))
e = int(eval(input()))
k = int(eval(input()))
sub = []
sub.append(b - a)
sub.append(c - a)
sub.append(d - a)
sub.append(e - a)
sub.append(c - b)
sub.append(d - b)
sub.append(e - b)
sub.append(d - c)
sub.append(e - c)
sub.append(e - d)
max = max(sub)
if max <= k:
print("Yay!")
else:
print(":(")
| false | 31.818182 | [
"-v = []",
"-e = \"\"",
"-for i in range(6):",
"- v.append(int(eval(input())))",
"-for i in range(len(v)):",
"- for j in range(i + 1, len(v)):",
"- if abs(v[i] - v[j]) > v[-1]:",
"- e = \":(\"",
"-if e != \"\":",
"- print(e)",
"+a = int(eval(input()))",
"+b = int(eval(input()))",
"+c = int(eval(input()))",
"+d = int(eval(input()))",
"+e = int(eval(input()))",
"+k = int(eval(input()))",
"+sub = []",
"+sub.append(b - a)",
"+sub.append(c - a)",
"+sub.append(d - a)",
"+sub.append(e - a)",
"+sub.append(c - b)",
"+sub.append(d - b)",
"+sub.append(e - b)",
"+sub.append(d - c)",
"+sub.append(e - c)",
"+sub.append(e - d)",
"+max = max(sub)",
"+if max <= k:",
"+ print(\"Yay!\")",
"- print(\"Yay!\")",
"+ print(\":(\")"
]
| false | 0.044374 | 0.043628 | 1.017094 | [
"s819157183",
"s484892242"
]
|
u934442292 | p03426 | python | s752706951 | s598612562 | 665 | 212 | 38,252 | 41,132 | Accepted | Accepted | 68.12 | import sys
import numpy as np
input = sys.stdin.readline
def dfs(H, W, D, A, Q, LR, ans):
position = [(-1, -1)] * (H * W + 1)
for h in range(H):
for w in range(W):
position[A[h][w]] = (h, w)
mp = np.zeros(shape=(H * W + 1), dtype=np.int64)
for i in range(1, H * W + 1 - D):
h, w = position[i]
y, x = position[i + D]
mp[i + D] = abs(x - w) + abs(y - h)
for d in range(1, D + 1):
mp[d::D] = np.cumsum(mp[d::D])
for i in range(Q):
l, r = LR[i]
ans[i] = mp[r] - mp[l]
def main():
H, W, D = list(map(int, input().split()))
A = np.zeros(shape=(H, W), dtype=np.int64)
for i in range(H):
A[i] = tuple(map(int, input().split()))
Q = int(eval(input()))
LR = np.zeros(shape=(Q, 2), dtype=np.int64)
for i in range(Q):
LR[i] = tuple(map(int, input().split()))
ans = np.zeros(shape=Q, dtype=np.int64)
dfs(H, W, D, A, Q, LR, ans)
print(("\n".join(map(str, ans))))
if __name__ == "__main__":
main()
| import sys
from itertools import accumulate
input = sys.stdin.readline
def dfs(H, W, D, A, Q, LR):
position = [(-1, -1)] * (H * W + 1)
for h in range(H):
for w in range(W):
position[A[h][w]] = (h, w)
mp = [0] * (H * W + 1)
for i in range(1, H * W + 1 - D):
h, w = position[i]
y, x = position[i + D]
mp[i + D] = abs(x - w) + abs(y - h)
for d in range(1, D + 1):
mp[d::D] = list(accumulate(mp[d::D]))
ans = [mp[r] - mp[l] for l, r in LR]
return ans
def main():
H, W, D = list(map(int, input().split()))
A = [None] * H
for i in range(H):
A[i] = tuple(map(int, input().split()))
Q = int(eval(input()))
LR = [None] * Q
for i in range(Q):
LR[i] = tuple(map(int, input().split()))
ans = [0] * Q
ans = dfs(H, W, D, A, Q, LR)
print(("\n".join(map(str, ans))))
if __name__ == "__main__":
main()
| 46 | 44 | 1,076 | 963 | import sys
import numpy as np
input = sys.stdin.readline
def dfs(H, W, D, A, Q, LR, ans):
position = [(-1, -1)] * (H * W + 1)
for h in range(H):
for w in range(W):
position[A[h][w]] = (h, w)
mp = np.zeros(shape=(H * W + 1), dtype=np.int64)
for i in range(1, H * W + 1 - D):
h, w = position[i]
y, x = position[i + D]
mp[i + D] = abs(x - w) + abs(y - h)
for d in range(1, D + 1):
mp[d::D] = np.cumsum(mp[d::D])
for i in range(Q):
l, r = LR[i]
ans[i] = mp[r] - mp[l]
def main():
H, W, D = list(map(int, input().split()))
A = np.zeros(shape=(H, W), dtype=np.int64)
for i in range(H):
A[i] = tuple(map(int, input().split()))
Q = int(eval(input()))
LR = np.zeros(shape=(Q, 2), dtype=np.int64)
for i in range(Q):
LR[i] = tuple(map(int, input().split()))
ans = np.zeros(shape=Q, dtype=np.int64)
dfs(H, W, D, A, Q, LR, ans)
print(("\n".join(map(str, ans))))
if __name__ == "__main__":
main()
| import sys
from itertools import accumulate
input = sys.stdin.readline
def dfs(H, W, D, A, Q, LR):
position = [(-1, -1)] * (H * W + 1)
for h in range(H):
for w in range(W):
position[A[h][w]] = (h, w)
mp = [0] * (H * W + 1)
for i in range(1, H * W + 1 - D):
h, w = position[i]
y, x = position[i + D]
mp[i + D] = abs(x - w) + abs(y - h)
for d in range(1, D + 1):
mp[d::D] = list(accumulate(mp[d::D]))
ans = [mp[r] - mp[l] for l, r in LR]
return ans
def main():
H, W, D = list(map(int, input().split()))
A = [None] * H
for i in range(H):
A[i] = tuple(map(int, input().split()))
Q = int(eval(input()))
LR = [None] * Q
for i in range(Q):
LR[i] = tuple(map(int, input().split()))
ans = [0] * Q
ans = dfs(H, W, D, A, Q, LR)
print(("\n".join(map(str, ans))))
if __name__ == "__main__":
main()
| false | 4.347826 | [
"-import numpy as np",
"+from itertools import accumulate",
"-def dfs(H, W, D, A, Q, LR, ans):",
"+def dfs(H, W, D, A, Q, LR):",
"- mp = np.zeros(shape=(H * W + 1), dtype=np.int64)",
"+ mp = [0] * (H * W + 1)",
"- mp[d::D] = np.cumsum(mp[d::D])",
"- for i in range(Q):",
"- l, r = LR[i]",
"- ans[i] = mp[r] - mp[l]",
"+ mp[d::D] = list(accumulate(mp[d::D]))",
"+ ans = [mp[r] - mp[l] for l, r in LR]",
"+ return ans",
"- A = np.zeros(shape=(H, W), dtype=np.int64)",
"+ A = [None] * H",
"- LR = np.zeros(shape=(Q, 2), dtype=np.int64)",
"+ LR = [None] * Q",
"- ans = np.zeros(shape=Q, dtype=np.int64)",
"- dfs(H, W, D, A, Q, LR, ans)",
"+ ans = [0] * Q",
"+ ans = dfs(H, W, D, A, Q, LR)"
]
| false | 0.186469 | 0.036811 | 5.065578 | [
"s752706951",
"s598612562"
]
|
u186838327 | p03666 | python | s193130850 | s336114952 | 345 | 178 | 2,940 | 38,768 | Accepted | Accepted | 48.41 | n, a, b, c, d = list(map(int, input().split()))
for i in range(n-1):
l = c*(n-1-i)-d*i
r = -c*i+(n-1-i)*d
if l <= b-a <= r:
print('YES')
exit()
else:
print('NO')
| n, a, b, c, d = list(map(int, input().split()))
for m in range(n):
l = c*(n-1-m)-d*m
r = d*(n-1-m)-c*m
if l <= b-a <= r:
print('YES')
exit()
else:
print('NO')
| 10 | 9 | 198 | 193 | n, a, b, c, d = list(map(int, input().split()))
for i in range(n - 1):
l = c * (n - 1 - i) - d * i
r = -c * i + (n - 1 - i) * d
if l <= b - a <= r:
print("YES")
exit()
else:
print("NO")
| n, a, b, c, d = list(map(int, input().split()))
for m in range(n):
l = c * (n - 1 - m) - d * m
r = d * (n - 1 - m) - c * m
if l <= b - a <= r:
print("YES")
exit()
else:
print("NO")
| false | 10 | [
"-for i in range(n - 1):",
"- l = c * (n - 1 - i) - d * i",
"- r = -c * i + (n - 1 - i) * d",
"+for m in range(n):",
"+ l = c * (n - 1 - m) - d * m",
"+ r = d * (n - 1 - m) - c * m"
]
| false | 0.493205 | 0.211795 | 2.328693 | [
"s193130850",
"s336114952"
]
|
u278052608 | p03160 | python | s645519823 | s038046590 | 150 | 115 | 14,480 | 20,964 | Accepted | Accepted | 23.33 | import math
n = int(eval(input()))
h = list(map(int,input().split(' ')))
'''
n-=1
inf = int(1e9+5)
dp = {}
def frog1(i):
if i==n:
return 0
if i in dp:
return dp[i]
a = 0
b = 0
if i+1>n:
a = inf
else:
a = frog1(i+1)+abs(h[i]-h[i+1])
if i+2>n:
b = inf
else:
b = frog1(i+2)+abs(h[i]-h[i+2])
dp[i] = min(a,b)
return dp[i]
'''
def solve(n,h):
dp = [0]*n
for i in reversed(list(range(0,n-1))):
if i==n-1:
dp[i] = 0
else:
if i==n-2:
dp[i] = abs(h[n-1]-h[n-2])
continue
a = 0
b = 0
if i+1<=n-1:
a = dp[i+1]+abs(h[i]-h[i+1])
if i+2<=n-1:
b = dp[i+2]+abs(h[i]-h[i+2])
dp[i] = min(a,b)
return dp[0]
print((solve(n,h)))
| import math
from functools import lru_cache
def Frog1():
n = int(eval(input()))
h = list(map(int,input().split(' ')))
@lru_cache(None)
def Solve(i):
if i==n-1:
return 0
if i==n-2:
return abs(h[i]-h[i+1])
return min(Solve(i+1)+abs(h[i]-h[i+1]),Solve(i+2)+abs(h[i]-h[i+2]))
dp = [0]*n
for i in reversed(list(range(n))):
if i==n-1:
dp[i] = 0
elif i==n-2:
dp[i] = abs(h[i]-h[i+1])
else:
dp[i] = min(dp[i+1]+abs(h[i]-h[i+1]),dp[i+2]+abs(h[i]-h[i+2]))
print((dp[0]))
Frog1()
| 46 | 24 | 912 | 616 | import math
n = int(eval(input()))
h = list(map(int, input().split(" ")))
"""
n-=1
inf = int(1e9+5)
dp = {}
def frog1(i):
if i==n:
return 0
if i in dp:
return dp[i]
a = 0
b = 0
if i+1>n:
a = inf
else:
a = frog1(i+1)+abs(h[i]-h[i+1])
if i+2>n:
b = inf
else:
b = frog1(i+2)+abs(h[i]-h[i+2])
dp[i] = min(a,b)
return dp[i]
"""
def solve(n, h):
dp = [0] * n
for i in reversed(list(range(0, n - 1))):
if i == n - 1:
dp[i] = 0
else:
if i == n - 2:
dp[i] = abs(h[n - 1] - h[n - 2])
continue
a = 0
b = 0
if i + 1 <= n - 1:
a = dp[i + 1] + abs(h[i] - h[i + 1])
if i + 2 <= n - 1:
b = dp[i + 2] + abs(h[i] - h[i + 2])
dp[i] = min(a, b)
return dp[0]
print((solve(n, h)))
| import math
from functools import lru_cache
def Frog1():
n = int(eval(input()))
h = list(map(int, input().split(" ")))
@lru_cache(None)
def Solve(i):
if i == n - 1:
return 0
if i == n - 2:
return abs(h[i] - h[i + 1])
return min(
Solve(i + 1) + abs(h[i] - h[i + 1]), Solve(i + 2) + abs(h[i] - h[i + 2])
)
dp = [0] * n
for i in reversed(list(range(n))):
if i == n - 1:
dp[i] = 0
elif i == n - 2:
dp[i] = abs(h[i] - h[i + 1])
else:
dp[i] = min(
dp[i + 1] + abs(h[i] - h[i + 1]), dp[i + 2] + abs(h[i] - h[i + 2])
)
print((dp[0]))
Frog1()
| false | 47.826087 | [
"-",
"-n = int(eval(input()))",
"-h = list(map(int, input().split(\" \")))",
"-\"\"\"",
"-n-=1",
"-inf = int(1e9+5)",
"-dp = {}",
"-def frog1(i):",
"- if i==n:",
"- return 0",
"- if i in dp:",
"- return dp[i]",
"- a = 0",
"- b = 0",
"- if i+1>n:",
"- a = inf",
"- else:",
"- a = frog1(i+1)+abs(h[i]-h[i+1])",
"- if i+2>n:",
"- b = inf",
"- else:",
"- b = frog1(i+2)+abs(h[i]-h[i+2])",
"- dp[i] = min(a,b)",
"- return dp[i]",
"-\"\"\"",
"+from functools import lru_cache",
"-def solve(n, h):",
"+def Frog1():",
"+ n = int(eval(input()))",
"+ h = list(map(int, input().split(\" \")))",
"+",
"+ @lru_cache(None)",
"+ def Solve(i):",
"+ if i == n - 1:",
"+ return 0",
"+ if i == n - 2:",
"+ return abs(h[i] - h[i + 1])",
"+ return min(",
"+ Solve(i + 1) + abs(h[i] - h[i + 1]), Solve(i + 2) + abs(h[i] - h[i + 2])",
"+ )",
"+",
"- for i in reversed(list(range(0, n - 1))):",
"+ for i in reversed(list(range(n))):",
"+ elif i == n - 2:",
"+ dp[i] = abs(h[i] - h[i + 1])",
"- if i == n - 2:",
"- dp[i] = abs(h[n - 1] - h[n - 2])",
"- continue",
"- a = 0",
"- b = 0",
"- if i + 1 <= n - 1:",
"- a = dp[i + 1] + abs(h[i] - h[i + 1])",
"- if i + 2 <= n - 1:",
"- b = dp[i + 2] + abs(h[i] - h[i + 2])",
"- dp[i] = min(a, b)",
"- return dp[0]",
"+ dp[i] = min(",
"+ dp[i + 1] + abs(h[i] - h[i + 1]), dp[i + 2] + abs(h[i] - h[i + 2])",
"+ )",
"+ print((dp[0]))",
"-print((solve(n, h)))",
"+Frog1()"
]
| false | 0.036397 | 0.082021 | 0.443748 | [
"s645519823",
"s038046590"
]
|
u562935282 | p03447 | python | s710194853 | s704138512 | 19 | 17 | 3,060 | 2,940 | Accepted | Accepted | 10.53 | x = int(eval(input()))
a = int(eval(input()))
b = int(eval(input()))
print(((x - a) % b)) | def main():
x, a, b = (int(eval(input())) for _ in range(3))
print(((x - 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()
| 4 | 15 | 72 | 267 | x = int(eval(input()))
a = int(eval(input()))
b = int(eval(input()))
print(((x - a) % b))
| def main():
x, a, b = (int(eval(input())) for _ in range(3))
print(((x - 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()
| false | 73.333333 | [
"-x = int(eval(input()))",
"-a = int(eval(input()))",
"-b = int(eval(input()))",
"-print(((x - a) % b))",
"+def main():",
"+ x, a, b = (int(eval(input())) for _ in range(3))",
"+ print(((x - 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()"
]
| false | 0.037413 | 0.037414 | 0.999968 | [
"s710194853",
"s704138512"
]
|
u796408111 | p03624 | python | s711982919 | s532934084 | 45 | 19 | 3,188 | 3,188 | Accepted | Accepted | 57.78 | S = eval(input())
wordNum = [0 for i in range(26)]
for wordOne in S:
idx = ord(wordOne) - ord('a')
wordNum[idx] += 1
ans = "None"
for i in range(26):
if wordNum[i] == 0:
ans = chr(ord('a') + i)
break;
print(ans)
| S = set(eval(input()))
allWord = set('abcdefghijklmnopqrstuvwxyz')
if len(S) == 26:
print("None")
else:
print((sorted(allWord - S)[0])) | 14 | 7 | 250 | 142 | S = eval(input())
wordNum = [0 for i in range(26)]
for wordOne in S:
idx = ord(wordOne) - ord("a")
wordNum[idx] += 1
ans = "None"
for i in range(26):
if wordNum[i] == 0:
ans = chr(ord("a") + i)
break
print(ans)
| S = set(eval(input()))
allWord = set("abcdefghijklmnopqrstuvwxyz")
if len(S) == 26:
print("None")
else:
print((sorted(allWord - S)[0]))
| false | 50 | [
"-S = eval(input())",
"-wordNum = [0 for i in range(26)]",
"-for wordOne in S:",
"- idx = ord(wordOne) - ord(\"a\")",
"- wordNum[idx] += 1",
"-ans = \"None\"",
"-for i in range(26):",
"- if wordNum[i] == 0:",
"- ans = chr(ord(\"a\") + i)",
"- break",
"-print(ans)",
"+S = set(eval(input()))",
"+allWord = set(\"abcdefghijklmnopqrstuvwxyz\")",
"+if len(S) == 26:",
"+ print(\"None\")",
"+else:",
"+ print((sorted(allWord - S)[0]))"
]
| false | 0.041714 | 0.040586 | 1.027779 | [
"s711982919",
"s532934084"
]
|
u972591645 | p02936 | python | s469669195 | s703083295 | 1,474 | 929 | 150,052 | 150,192 | Accepted | Accepted | 36.97 | import collections
n, q = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(n-1)]
px = [list(map(int, input().split())) for _ in range(q)]
c = [[] for _ in range(n)]
for a, b in ab:
a, b = a-1, b-1
c[a].append(b)
c[b].append(a)
point = [0] * n
for p, x in px:
point[p-1] += x
parents = [0] * n
ans = [0] * n
q = collections.deque()
q.append(0)
while q:
v = q.pop()
ans[v] = ans[parents[v]] + point[v]
for i in c[v]:
if i == parents[v]:
continue
parents[i] = v
q.append(i)
print((' '.join(list(map(str, ans))))) | def main():
import sys
readline = sys.stdin.buffer.readline
import collections
n, q = list(map(int, readline().split()))
ab = [list(map(int, readline().split())) for _ in range(n-1)]
px = [list(map(int, readline().split())) for _ in range(q)]
c = [[] for _ in range(n)]
for a, b in ab:
a, b = a-1, b-1
c[a].append(b)
c[b].append(a)
point = [0] * n
for p, x in px:
point[p-1] += x
parents = [0] * n
ans = [0] * n
q = collections.deque()
q.append(0)
while q:
v = q.pop()
ans[v] = ans[parents[v]] + point[v]
for i in c[v]:
if i == parents[v]:
continue
parents[i] = v
q.append(i)
print((' '.join(list(map(str, ans)))))
main() | 29 | 34 | 633 | 823 | import collections
n, q = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(n - 1)]
px = [list(map(int, input().split())) for _ in range(q)]
c = [[] for _ in range(n)]
for a, b in ab:
a, b = a - 1, b - 1
c[a].append(b)
c[b].append(a)
point = [0] * n
for p, x in px:
point[p - 1] += x
parents = [0] * n
ans = [0] * n
q = collections.deque()
q.append(0)
while q:
v = q.pop()
ans[v] = ans[parents[v]] + point[v]
for i in c[v]:
if i == parents[v]:
continue
parents[i] = v
q.append(i)
print((" ".join(list(map(str, ans)))))
| def main():
import sys
readline = sys.stdin.buffer.readline
import collections
n, q = list(map(int, readline().split()))
ab = [list(map(int, readline().split())) for _ in range(n - 1)]
px = [list(map(int, readline().split())) for _ in range(q)]
c = [[] for _ in range(n)]
for a, b in ab:
a, b = a - 1, b - 1
c[a].append(b)
c[b].append(a)
point = [0] * n
for p, x in px:
point[p - 1] += x
parents = [0] * n
ans = [0] * n
q = collections.deque()
q.append(0)
while q:
v = q.pop()
ans[v] = ans[parents[v]] + point[v]
for i in c[v]:
if i == parents[v]:
continue
parents[i] = v
q.append(i)
print((" ".join(list(map(str, ans)))))
main()
| false | 14.705882 | [
"-import collections",
"+def main():",
"+ import sys",
"-n, q = list(map(int, input().split()))",
"-ab = [list(map(int, input().split())) for _ in range(n - 1)]",
"-px = [list(map(int, input().split())) for _ in range(q)]",
"-c = [[] for _ in range(n)]",
"-for a, b in ab:",
"- a, b = a - 1, b - 1",
"- c[a].append(b)",
"- c[b].append(a)",
"-point = [0] * n",
"-for p, x in px:",
"- point[p - 1] += x",
"-parents = [0] * n",
"-ans = [0] * n",
"-q = collections.deque()",
"-q.append(0)",
"-while q:",
"- v = q.pop()",
"- ans[v] = ans[parents[v]] + point[v]",
"- for i in c[v]:",
"- if i == parents[v]:",
"- continue",
"- parents[i] = v",
"- q.append(i)",
"-print((\" \".join(list(map(str, ans)))))",
"+ readline = sys.stdin.buffer.readline",
"+ import collections",
"+",
"+ n, q = list(map(int, readline().split()))",
"+ ab = [list(map(int, readline().split())) for _ in range(n - 1)]",
"+ px = [list(map(int, readline().split())) for _ in range(q)]",
"+ c = [[] for _ in range(n)]",
"+ for a, b in ab:",
"+ a, b = a - 1, b - 1",
"+ c[a].append(b)",
"+ c[b].append(a)",
"+ point = [0] * n",
"+ for p, x in px:",
"+ point[p - 1] += x",
"+ parents = [0] * n",
"+ ans = [0] * n",
"+ q = collections.deque()",
"+ q.append(0)",
"+ while q:",
"+ v = q.pop()",
"+ ans[v] = ans[parents[v]] + point[v]",
"+ for i in c[v]:",
"+ if i == parents[v]:",
"+ continue",
"+ parents[i] = v",
"+ q.append(i)",
"+ print((\" \".join(list(map(str, ans)))))",
"+",
"+",
"+main()"
]
| false | 0.046944 | 0.045497 | 1.031808 | [
"s469669195",
"s703083295"
]
|
u956866689 | p03494 | python | s560513719 | s207250893 | 19 | 17 | 3,060 | 3,060 | Accepted | Accepted | 10.53 |
n = int(eval(input()))
l = input().split()
l_i = [int(j) for j in l]
min = l_i[0]
count = 0
flag = True
while True:
for i in range(n):
if l_i[i] % 2 == 0:
l_i[i] = l_i[i] / 2
else :
flag = False
if flag:
count += 1
else:
break
print(count)
| # -*- coding:utf-8 -*-
import math
n = int(eval(input()))
a = list(map(int, input().split()))
ans = float("inf")
for i in a:
ans = min(ans, len(bin(i)) - bin(i).rfind("1") - 1)
print(ans)
| 21 | 11 | 326 | 199 | n = int(eval(input()))
l = input().split()
l_i = [int(j) for j in l]
min = l_i[0]
count = 0
flag = True
while True:
for i in range(n):
if l_i[i] % 2 == 0:
l_i[i] = l_i[i] / 2
else:
flag = False
if flag:
count += 1
else:
break
print(count)
| # -*- coding:utf-8 -*-
import math
n = int(eval(input()))
a = list(map(int, input().split()))
ans = float("inf")
for i in a:
ans = min(ans, len(bin(i)) - bin(i).rfind("1") - 1)
print(ans)
| false | 47.619048 | [
"+# -*- coding:utf-8 -*-",
"+import math",
"+",
"-l = input().split()",
"-l_i = [int(j) for j in l]",
"-min = l_i[0]",
"-count = 0",
"-flag = True",
"-while True:",
"- for i in range(n):",
"- if l_i[i] % 2 == 0:",
"- l_i[i] = l_i[i] / 2",
"- else:",
"- flag = False",
"- if flag:",
"- count += 1",
"- else:",
"- break",
"-print(count)",
"+a = list(map(int, input().split()))",
"+ans = float(\"inf\")",
"+for i in a:",
"+ ans = min(ans, len(bin(i)) - bin(i).rfind(\"1\") - 1)",
"+print(ans)"
]
| false | 0.033941 | 0.038021 | 0.892696 | [
"s560513719",
"s207250893"
]
|
u621643202 | p03448 | python | s472774782 | s999117638 | 42 | 33 | 3,064 | 3,064 | Accepted | Accepted | 21.43 | a, b, c, x = [int(eval(input())) for _ in range(4)]
count = 0
for i in range(a, -1, -1):
i_tmp = i * 500
for j in range(b, -1, -1):
j_tmp = j * 100 + i_tmp
for k in range(c, -1, -1):
sum = k * 50 + j_tmp
if sum == x:
count += 1
print(count) | a, b, c, x = [int(eval(input())) for _ in range(4)]
count = 0
for i in range(a, -1, -1):
i_tmp = i * 500
if i_tmp > x:
continue
for j in range(b, -1, -1):
j_tmp = j * 100 + i_tmp
if j_tmp > x:
continue
for k in range(c, -1, -1):
sum = k * 50 + j_tmp
if sum == x:
count += 1
print(count) | 13 | 17 | 312 | 394 | a, b, c, x = [int(eval(input())) for _ in range(4)]
count = 0
for i in range(a, -1, -1):
i_tmp = i * 500
for j in range(b, -1, -1):
j_tmp = j * 100 + i_tmp
for k in range(c, -1, -1):
sum = k * 50 + j_tmp
if sum == x:
count += 1
print(count)
| a, b, c, x = [int(eval(input())) for _ in range(4)]
count = 0
for i in range(a, -1, -1):
i_tmp = i * 500
if i_tmp > x:
continue
for j in range(b, -1, -1):
j_tmp = j * 100 + i_tmp
if j_tmp > x:
continue
for k in range(c, -1, -1):
sum = k * 50 + j_tmp
if sum == x:
count += 1
print(count)
| false | 23.529412 | [
"+ if i_tmp > x:",
"+ continue",
"+ if j_tmp > x:",
"+ continue"
]
| false | 0.08178 | 0.055073 | 1.484928 | [
"s472774782",
"s999117638"
]
|
u864197622 | p02788 | python | s283721101 | s728641937 | 1,018 | 688 | 68,700 | 76,380 | Accepted | Accepted | 32.42 | import sys
input = sys.stdin.readline
from collections import deque
from operator import itemgetter
key = itemgetter(0)
N, D, A = list(map(int, input().split()))
X = []
for _ in range(N):
x, h = list(map(int, input().split()))
X.append((x, h))
X = sorted(X)[::-1]
Q = deque([])
ans = 0
k = 0
while X:
if len(Q) == 0 or X[-1][0] <= Q[0][0]:
x, h = X.pop()
h = max(h - k * A, 0)
a = (h + A - 1) // A
ans += a
k += a
deque.append(Q, (x + 2 * D, a))
else:
x, a = deque.popleft(Q)
k -= a
print(ans) | import sys
input = sys.stdin.readline
from collections import deque
from operator import itemgetter
N, D, A = list(map(int, input().split()))
X = []
for _ in range(N):
x, h = list(map(int, input().split()))
X.append((x, h))
X = sorted(X, key = itemgetter(0))[::-1]
Q = deque([])
ans = 0
k = 0
while X:
if len(Q) == 0 or X[-1][0] <= Q[0][0]:
x, h = X.pop()
h = max(h - k * A, 0)
a = (h + A - 1) // A
ans += a
k += a
deque.append(Q, (x + 2 * D, a))
else:
x, a = deque.popleft(Q)
k -= a
print(ans)
| 29 | 28 | 592 | 593 | import sys
input = sys.stdin.readline
from collections import deque
from operator import itemgetter
key = itemgetter(0)
N, D, A = list(map(int, input().split()))
X = []
for _ in range(N):
x, h = list(map(int, input().split()))
X.append((x, h))
X = sorted(X)[::-1]
Q = deque([])
ans = 0
k = 0
while X:
if len(Q) == 0 or X[-1][0] <= Q[0][0]:
x, h = X.pop()
h = max(h - k * A, 0)
a = (h + A - 1) // A
ans += a
k += a
deque.append(Q, (x + 2 * D, a))
else:
x, a = deque.popleft(Q)
k -= a
print(ans)
| import sys
input = sys.stdin.readline
from collections import deque
from operator import itemgetter
N, D, A = list(map(int, input().split()))
X = []
for _ in range(N):
x, h = list(map(int, input().split()))
X.append((x, h))
X = sorted(X, key=itemgetter(0))[::-1]
Q = deque([])
ans = 0
k = 0
while X:
if len(Q) == 0 or X[-1][0] <= Q[0][0]:
x, h = X.pop()
h = max(h - k * A, 0)
a = (h + A - 1) // A
ans += a
k += a
deque.append(Q, (x + 2 * D, a))
else:
x, a = deque.popleft(Q)
k -= a
print(ans)
| false | 3.448276 | [
"-key = itemgetter(0)",
"-X = sorted(X)[::-1]",
"+X = sorted(X, key=itemgetter(0))[::-1]"
]
| false | 0.041785 | 0.041883 | 0.997665 | [
"s283721101",
"s728641937"
]
|
u268793453 | p03169 | python | s155011401 | s886878256 | 1,342 | 715 | 502,308 | 159,112 | Accepted | Accepted | 46.72 | from collections import Counter
n = int(eval(input()))
A = [int(i) for i in input().split()]
C = Counter(A)
a, b, c = [C[i] for i in range(3, 0, -1)]
DP = [[[-1] * (a + b + c + 1) for i in range(a + b + 1)] for j in range(a + 1)]
DP[0][0][0] = 0
for i in range(a + 1):
for j in range(a + b - i + 1):
for k in range(a + b + c - i - j + 1):
if i == j == k == 0:
continue
DP[i][j][k] = 1
if i > 0: DP[i][j][k] += i / n * DP[i - 1][j + 1][k]
if j > 0: DP[i][j][k] += j / n * DP[i][j - 1][k + 1]
if k > 0: DP[i][j][k] += k / n * DP[i][j][k - 1]
DP[i][j][k] *= n / (i + j + k)
print((DP[a][b][c])) | from collections import Counter
n = int(eval(input()))
A = [int(i) for i in input().split()]
C = Counter(A)
a, b, c = [C[i] for i in range(3, 0, -1)]
DP = [[[0] * (a + b + c - i - j + 1) for j in range(a + b - i + 1)] for i in range(a + 1)]
for i in range(a + 1):
for j in range(a + b - i + 1):
for k in range(a + b + c - i - j + 1):
if i == j == k == 0:
continue
DP[i][j][k] = 1
if i > 0: DP[i][j][k] += i / n * DP[i - 1][j + 1][k]
if j > 0: DP[i][j][k] += j / n * DP[i][j - 1][k + 1]
if k > 0: DP[i][j][k] += k / n * DP[i][j][k - 1]
DP[i][j][k] *= n / (i + j + k)
print((DP[a][b][c])) | 22 | 21 | 708 | 702 | from collections import Counter
n = int(eval(input()))
A = [int(i) for i in input().split()]
C = Counter(A)
a, b, c = [C[i] for i in range(3, 0, -1)]
DP = [[[-1] * (a + b + c + 1) for i in range(a + b + 1)] for j in range(a + 1)]
DP[0][0][0] = 0
for i in range(a + 1):
for j in range(a + b - i + 1):
for k in range(a + b + c - i - j + 1):
if i == j == k == 0:
continue
DP[i][j][k] = 1
if i > 0:
DP[i][j][k] += i / n * DP[i - 1][j + 1][k]
if j > 0:
DP[i][j][k] += j / n * DP[i][j - 1][k + 1]
if k > 0:
DP[i][j][k] += k / n * DP[i][j][k - 1]
DP[i][j][k] *= n / (i + j + k)
print((DP[a][b][c]))
| from collections import Counter
n = int(eval(input()))
A = [int(i) for i in input().split()]
C = Counter(A)
a, b, c = [C[i] for i in range(3, 0, -1)]
DP = [
[[0] * (a + b + c - i - j + 1) for j in range(a + b - i + 1)] for i in range(a + 1)
]
for i in range(a + 1):
for j in range(a + b - i + 1):
for k in range(a + b + c - i - j + 1):
if i == j == k == 0:
continue
DP[i][j][k] = 1
if i > 0:
DP[i][j][k] += i / n * DP[i - 1][j + 1][k]
if j > 0:
DP[i][j][k] += j / n * DP[i][j - 1][k + 1]
if k > 0:
DP[i][j][k] += k / n * DP[i][j][k - 1]
DP[i][j][k] *= n / (i + j + k)
print((DP[a][b][c]))
| false | 4.545455 | [
"-DP = [[[-1] * (a + b + c + 1) for i in range(a + b + 1)] for j in range(a + 1)]",
"-DP[0][0][0] = 0",
"+DP = [",
"+ [[0] * (a + b + c - i - j + 1) for j in range(a + b - i + 1)] for i in range(a + 1)",
"+]"
]
| false | 0.037988 | 0.041277 | 0.920335 | [
"s155011401",
"s886878256"
]
|
u896065593 | p02392 | python | s160491380 | s678118278 | 30 | 20 | 7,640 | 7,644 | Accepted | Accepted | 33.33 | a, b, c = list(map(int, input().split()))
if a < b and b < c:
print("Yes")
else:
print("No") | # ??°???a,b,c?????????????????§???a<b<c??§????????°Yes???????????§???????????°No??¨????????????????????°??????
a, b, c = list(map(int, input().split()))
if a < b < c:
print("Yes")
else:
print("No") | 5 | 6 | 98 | 206 | a, b, c = list(map(int, input().split()))
if a < b and b < c:
print("Yes")
else:
print("No")
| # ??°???a,b,c?????????????????§???a<b<c??§????????°Yes???????????§???????????°No??¨????????????????????°??????
a, b, c = list(map(int, input().split()))
if a < b < c:
print("Yes")
else:
print("No")
| false | 16.666667 | [
"+# ??°???a,b,c?????????????????§???a<b<c??§????????°Yes???????????§???????????°No??¨????????????????????°??????",
"-if a < b and b < c:",
"+if a < b < c:"
]
| false | 0.032777 | 0.034702 | 0.944505 | [
"s160491380",
"s678118278"
]
|
u351426847 | p02995 | python | s889717113 | s030678201 | 75 | 36 | 6,356 | 5,320 | Accepted | Accepted | 52 | # coding: utf-8
import re
import bisect
from datetime import datetime as dt
import bisect
import fractions
def gcd(a, b):
return fractions.gcd(a, b)
def lcm(a, b):
return a * b // gcd(a, b)
def calc(n, a, b):
return n//a + n//b - n//lcm(a,b)
if __name__ == '__main__':
a, b, c, d = list(map(int, input().split()))
## これで通った
# num1 = b - calc(b,c,d)
# num2 = (a-1) - calc(a-1, c,d)
# print(num1-num2)
## これはとおらない
ans = calc(b, c, d) - calc(a - 1, c, d)
print((int(b - a + 1 - ans)))
| # coding: utf-8
import re
import bisect
from datetime import datetime as dt
import bisect
import fractions
def gcd(a, b):
return fractions.gcd(a, b)
def lcm(a, b):
return a * b // gcd(a, b)
def calc(n, a, b):
return int(n//a + n//b - n//lcm(a,b))
if __name__ == '__main__':
a, b, c, d = list(map(int, input().split()))
ans = calc(b, c, d) - calc(a - 1, c, d)
print((b - a + 1 - ans))
| 26 | 20 | 548 | 423 | # coding: utf-8
import re
import bisect
from datetime import datetime as dt
import bisect
import fractions
def gcd(a, b):
return fractions.gcd(a, b)
def lcm(a, b):
return a * b // gcd(a, b)
def calc(n, a, b):
return n // a + n // b - n // lcm(a, b)
if __name__ == "__main__":
a, b, c, d = list(map(int, input().split()))
## これで通った
# num1 = b - calc(b,c,d)
# num2 = (a-1) - calc(a-1, c,d)
# print(num1-num2)
## これはとおらない
ans = calc(b, c, d) - calc(a - 1, c, d)
print((int(b - a + 1 - ans)))
| # coding: utf-8
import re
import bisect
from datetime import datetime as dt
import bisect
import fractions
def gcd(a, b):
return fractions.gcd(a, b)
def lcm(a, b):
return a * b // gcd(a, b)
def calc(n, a, b):
return int(n // a + n // b - n // lcm(a, b))
if __name__ == "__main__":
a, b, c, d = list(map(int, input().split()))
ans = calc(b, c, d) - calc(a - 1, c, d)
print((b - a + 1 - ans))
| false | 23.076923 | [
"- return n // a + n // b - n // lcm(a, b)",
"+ return int(n // a + n // b - n // lcm(a, b))",
"- ## これで通った",
"- # num1 = b - calc(b,c,d)",
"- # num2 = (a-1) - calc(a-1, c,d)",
"- # print(num1-num2)",
"- ## これはとおらない",
"- print((int(b - a + 1 - ans)))",
"+ print((b - a + 1 - ans))"
]
| false | 0.049567 | 0.055199 | 0.897977 | [
"s889717113",
"s030678201"
]
|
u983918956 | p03722 | python | s648846903 | s673350909 | 947 | 462 | 3,308 | 52,440 | Accepted | Accepted | 51.21 | inf = float('inf')
# ベルマンフォード法
# 計算量O(VE) V:頂点数, E:辺の数
# [引数] n:頂点数, edges:辺集合, start:始点, end:終点
# [返り値] dist:startからの最短距離, exists_negative_cycle: 負閉路が存在するかどうか
def bellmanford(n : int, edges : list, start : int, goal : int) -> (list, bool):
dist = [inf] * n
dist[start] = 0
exist_negative_cycle = True
# 負閉路を含まないとき、頂点数nなら更新は高々n-1回で済む
for _ in range(N-1):
for v, nv, w in edges:
if dist[nv] > dist[v] + w:
dist[nv] = dist[v] + w
# (1)グラフに負閉路が含まれるときの検出
# N回目で更新があったとき、グラフは負閉路を含む
# for v, nv, w in edges:
# if dist[nv] > dist[v] + w:
# is_cycle = False
# (2)startとendのパスに負閉路が含まれるときの検出
is_updated = [False] * n
for _ in range(N):
for v, nv, w in edges:
if dist[nv] > dist[v] + w:
dist[nv] = dist[v] + w
is_updated[nv] = True
if is_updated[v] is True:
is_updated[nv] = True
exist_negative_cycle = is_updated[goal]
return dist, exist_negative_cycle
N, M = list(map(int,input().split()))
edges = []
for _ in range(M):
a, b, c = list(map(int,input().split()))
a -= 1; b -= 1
edges.append((a, b, -c))
dist, exist_negative_cycle = bellmanford(N, edges, 0, N-1)
if exist_negative_cycle is True:
ans = "inf"
else:
ans = -dist[N-1]
print(ans) | inf = float('inf')
# ベルマンフォード法 計算量(VE)
# [引数]: 隣接リスト, 始点, 終点
class Bellmanford:
def __init__(self, to : list, start : int, goal : int):
self.N = len(to)
self.to = [s[:] for s in to]
self.start = start
self.goal = goal
self.dist = [inf] * self.N
self.dist[start] = 0
self.exists_negative_cycle = False
self.exists_negative_cycle_stog = False
self.is_updated = [False] * self.N
# self.distを更新
def update(self) -> None:
for _ in range(self.N - 1):
for v, s in enumerate(self.to):
if not s: continue
for nv, w in s:
if self.dist[nv] > self.dist[v] + w:
self.dist[nv] = self.dist[v] + w
# グラフの負閉路検出
def detection(self) -> bool:
for v, s in enumerate(self.to):
if not s: continue
for nv, w in s:
if self.dist[nv] > self.dist[v] + w:
self.dist[nv] = self.dist[v] + w
self.exists_negative_cycle = True
return self.exists_negative_cycle
# スタートからゴールまでのパスの負閉路検出
def detection_stog(self) -> bool:
for _ in range(self.N):
for v, s in enumerate(self.to):
if not s: continue
for nv, w in s:
if self.dist[nv] > self.dist[v] + w:
self.dist[nv] = self.dist[v] + w
self.is_updated[nv] = True
if self.is_updated[v] is True:
self.is_updated[nv] = True
self.exists_negative_cycle_stog = self.is_updated[self.goal]
return self.exists_negative_cycle_stog
N, M = list(map(int,input().split()))
to = [[] for _ in range(N)]
for _ in range(M):
a, b, c = list(map(int,input().split()))
a -= 1; b -= 1
to[a].append((b, -c))
BF = Bellmanford(to, 0, N-1)
BF.update()
if BF.detection_stog():
ans = "inf"
else:
ans = -BF.dist[N-1]
print(ans) | 52 | 64 | 1,388 | 2,069 | inf = float("inf")
# ベルマンフォード法
# 計算量O(VE) V:頂点数, E:辺の数
# [引数] n:頂点数, edges:辺集合, start:始点, end:終点
# [返り値] dist:startからの最短距離, exists_negative_cycle: 負閉路が存在するかどうか
def bellmanford(n: int, edges: list, start: int, goal: int) -> (list, bool):
dist = [inf] * n
dist[start] = 0
exist_negative_cycle = True
# 負閉路を含まないとき、頂点数nなら更新は高々n-1回で済む
for _ in range(N - 1):
for v, nv, w in edges:
if dist[nv] > dist[v] + w:
dist[nv] = dist[v] + w
# (1)グラフに負閉路が含まれるときの検出
# N回目で更新があったとき、グラフは負閉路を含む
# for v, nv, w in edges:
# if dist[nv] > dist[v] + w:
# is_cycle = False
# (2)startとendのパスに負閉路が含まれるときの検出
is_updated = [False] * n
for _ in range(N):
for v, nv, w in edges:
if dist[nv] > dist[v] + w:
dist[nv] = dist[v] + w
is_updated[nv] = True
if is_updated[v] is True:
is_updated[nv] = True
exist_negative_cycle = is_updated[goal]
return dist, exist_negative_cycle
N, M = list(map(int, input().split()))
edges = []
for _ in range(M):
a, b, c = list(map(int, input().split()))
a -= 1
b -= 1
edges.append((a, b, -c))
dist, exist_negative_cycle = bellmanford(N, edges, 0, N - 1)
if exist_negative_cycle is True:
ans = "inf"
else:
ans = -dist[N - 1]
print(ans)
| inf = float("inf")
# ベルマンフォード法 計算量(VE)
# [引数]: 隣接リスト, 始点, 終点
class Bellmanford:
def __init__(self, to: list, start: int, goal: int):
self.N = len(to)
self.to = [s[:] for s in to]
self.start = start
self.goal = goal
self.dist = [inf] * self.N
self.dist[start] = 0
self.exists_negative_cycle = False
self.exists_negative_cycle_stog = False
self.is_updated = [False] * self.N
# self.distを更新
def update(self) -> None:
for _ in range(self.N - 1):
for v, s in enumerate(self.to):
if not s:
continue
for nv, w in s:
if self.dist[nv] > self.dist[v] + w:
self.dist[nv] = self.dist[v] + w
# グラフの負閉路検出
def detection(self) -> bool:
for v, s in enumerate(self.to):
if not s:
continue
for nv, w in s:
if self.dist[nv] > self.dist[v] + w:
self.dist[nv] = self.dist[v] + w
self.exists_negative_cycle = True
return self.exists_negative_cycle
# スタートからゴールまでのパスの負閉路検出
def detection_stog(self) -> bool:
for _ in range(self.N):
for v, s in enumerate(self.to):
if not s:
continue
for nv, w in s:
if self.dist[nv] > self.dist[v] + w:
self.dist[nv] = self.dist[v] + w
self.is_updated[nv] = True
if self.is_updated[v] is True:
self.is_updated[nv] = True
self.exists_negative_cycle_stog = self.is_updated[self.goal]
return self.exists_negative_cycle_stog
N, M = list(map(int, input().split()))
to = [[] for _ in range(N)]
for _ in range(M):
a, b, c = list(map(int, input().split()))
a -= 1
b -= 1
to[a].append((b, -c))
BF = Bellmanford(to, 0, N - 1)
BF.update()
if BF.detection_stog():
ans = "inf"
else:
ans = -BF.dist[N - 1]
print(ans)
| false | 18.75 | [
"-# ベルマンフォード法",
"-# 計算量O(VE) V:頂点数, E:辺の数",
"-# [引数] n:頂点数, edges:辺集合, start:始点, end:終点",
"-# [返り値] dist:startからの最短距離, exists_negative_cycle: 負閉路が存在するかどうか",
"-def bellmanford(n: int, edges: list, start: int, goal: int) -> (list, bool):",
"- dist = [inf] * n",
"- dist[start] = 0",
"- exist_negative_cycle = True",
"- # 負閉路を含まないとき、頂点数nなら更新は高々n-1回で済む",
"- for _ in range(N - 1):",
"- for v, nv, w in edges:",
"- if dist[nv] > dist[v] + w:",
"- dist[nv] = dist[v] + w",
"- # (1)グラフに負閉路が含まれるときの検出",
"- # N回目で更新があったとき、グラフは負閉路を含む",
"- # for v, nv, w in edges:",
"- # if dist[nv] > dist[v] + w:",
"- # is_cycle = False",
"- # (2)startとendのパスに負閉路が含まれるときの検出",
"- is_updated = [False] * n",
"- for _ in range(N):",
"- for v, nv, w in edges:",
"- if dist[nv] > dist[v] + w:",
"- dist[nv] = dist[v] + w",
"- is_updated[nv] = True",
"- if is_updated[v] is True:",
"- is_updated[nv] = True",
"- exist_negative_cycle = is_updated[goal]",
"- return dist, exist_negative_cycle",
"+# ベルマンフォード法 計算量(VE)",
"+# [引数]: 隣接リスト, 始点, 終点",
"+class Bellmanford:",
"+ def __init__(self, to: list, start: int, goal: int):",
"+ self.N = len(to)",
"+ self.to = [s[:] for s in to]",
"+ self.start = start",
"+ self.goal = goal",
"+ self.dist = [inf] * self.N",
"+ self.dist[start] = 0",
"+ self.exists_negative_cycle = False",
"+ self.exists_negative_cycle_stog = False",
"+ self.is_updated = [False] * self.N",
"+",
"+ # self.distを更新",
"+ def update(self) -> None:",
"+ for _ in range(self.N - 1):",
"+ for v, s in enumerate(self.to):",
"+ if not s:",
"+ continue",
"+ for nv, w in s:",
"+ if self.dist[nv] > self.dist[v] + w:",
"+ self.dist[nv] = self.dist[v] + w",
"+",
"+ # グラフの負閉路検出",
"+ def detection(self) -> bool:",
"+ for v, s in enumerate(self.to):",
"+ if not s:",
"+ continue",
"+ for nv, w in s:",
"+ if self.dist[nv] > self.dist[v] + w:",
"+ self.dist[nv] = self.dist[v] + w",
"+ self.exists_negative_cycle = True",
"+ return self.exists_negative_cycle",
"+",
"+ # スタートからゴールまでのパスの負閉路検出",
"+ def detection_stog(self) -> bool:",
"+ for _ in range(self.N):",
"+ for v, s in enumerate(self.to):",
"+ if not s:",
"+ continue",
"+ for nv, w in s:",
"+ if self.dist[nv] > self.dist[v] + w:",
"+ self.dist[nv] = self.dist[v] + w",
"+ self.is_updated[nv] = True",
"+ if self.is_updated[v] is True:",
"+ self.is_updated[nv] = True",
"+ self.exists_negative_cycle_stog = self.is_updated[self.goal]",
"+ return self.exists_negative_cycle_stog",
"-edges = []",
"+to = [[] for _ in range(N)]",
"- edges.append((a, b, -c))",
"-dist, exist_negative_cycle = bellmanford(N, edges, 0, N - 1)",
"-if exist_negative_cycle is True:",
"+ to[a].append((b, -c))",
"+BF = Bellmanford(to, 0, N - 1)",
"+BF.update()",
"+if BF.detection_stog():",
"- ans = -dist[N - 1]",
"+ ans = -BF.dist[N - 1]"
]
| false | 0.081098 | 0.123123 | 0.658672 | [
"s648846903",
"s673350909"
]
|
u764956288 | p02684 | python | s836824575 | s723806424 | 142 | 118 | 32,668 | 32,376 | Accepted | Accepted | 16.9 | # import numpy as np
# import queue
# import heapq
def main():
N, K = list(map(int, input().split()))
As = list(map(int, input().split()))
f_loop = [1]
passed = set(f_loop)
next_idx = 1
while True:
next_town = As[next_idx-1]
if next_town in passed:
idx_head = f_loop.index(next_town)
n_loop = len(f_loop) - idx_head
break
passed.add(next_town)
f_loop.append(next_town)
next_idx = next_town
if idx_head + n_loop <= K:
target = idx_head + (K - idx_head - n_loop) % n_loop
else:
target = K
print((f_loop[target]))
if __name__ == "__main__":
main()
| def main():
_, n_teleport = list(map(int, input().split()))
towns = [0] + list(map(int, input().split()))
visited_list = []
visited_set = set()
next_town = 1
while 1:
if next_town in visited_set:
loop_start_at = visited_list.index(next_town)
loop_length = len(visited_list) - loop_start_at
break
visited_list.append(next_town)
visited_set.add(next_town)
next_town = towns[next_town]
if n_teleport < loop_start_at:
end_point = n_teleport
else:
end_point = loop_start_at + (n_teleport - loop_start_at) % loop_length
print((visited_list[end_point]))
if __name__ == "__main__":
main()
| 34 | 28 | 711 | 731 | # import numpy as np
# import queue
# import heapq
def main():
N, K = list(map(int, input().split()))
As = list(map(int, input().split()))
f_loop = [1]
passed = set(f_loop)
next_idx = 1
while True:
next_town = As[next_idx - 1]
if next_town in passed:
idx_head = f_loop.index(next_town)
n_loop = len(f_loop) - idx_head
break
passed.add(next_town)
f_loop.append(next_town)
next_idx = next_town
if idx_head + n_loop <= K:
target = idx_head + (K - idx_head - n_loop) % n_loop
else:
target = K
print((f_loop[target]))
if __name__ == "__main__":
main()
| def main():
_, n_teleport = list(map(int, input().split()))
towns = [0] + list(map(int, input().split()))
visited_list = []
visited_set = set()
next_town = 1
while 1:
if next_town in visited_set:
loop_start_at = visited_list.index(next_town)
loop_length = len(visited_list) - loop_start_at
break
visited_list.append(next_town)
visited_set.add(next_town)
next_town = towns[next_town]
if n_teleport < loop_start_at:
end_point = n_teleport
else:
end_point = loop_start_at + (n_teleport - loop_start_at) % loop_length
print((visited_list[end_point]))
if __name__ == "__main__":
main()
| false | 17.647059 | [
"-# import numpy as np",
"-# import queue",
"-# import heapq",
"- N, K = list(map(int, input().split()))",
"- As = list(map(int, input().split()))",
"- f_loop = [1]",
"- passed = set(f_loop)",
"- next_idx = 1",
"- while True:",
"- next_town = As[next_idx - 1]",
"- if next_town in passed:",
"- idx_head = f_loop.index(next_town)",
"- n_loop = len(f_loop) - idx_head",
"+ _, n_teleport = list(map(int, input().split()))",
"+ towns = [0] + list(map(int, input().split()))",
"+ visited_list = []",
"+ visited_set = set()",
"+ next_town = 1",
"+ while 1:",
"+ if next_town in visited_set:",
"+ loop_start_at = visited_list.index(next_town)",
"+ loop_length = len(visited_list) - loop_start_at",
"- passed.add(next_town)",
"- f_loop.append(next_town)",
"- next_idx = next_town",
"- if idx_head + n_loop <= K:",
"- target = idx_head + (K - idx_head - n_loop) % n_loop",
"+ visited_list.append(next_town)",
"+ visited_set.add(next_town)",
"+ next_town = towns[next_town]",
"+ if n_teleport < loop_start_at:",
"+ end_point = n_teleport",
"- target = K",
"- print((f_loop[target]))",
"+ end_point = loop_start_at + (n_teleport - loop_start_at) % loop_length",
"+ print((visited_list[end_point]))"
]
| false | 0.03568 | 0.035525 | 1.004374 | [
"s836824575",
"s723806424"
]
|
u867826040 | p03448 | python | s781173779 | s838841975 | 186 | 50 | 39,536 | 2,940 | Accepted | Accepted | 73.12 | a, b, c, X = [int(eval(input())) for i in range(4)]
A = 0
for i in range(a + 1):
for j in range(b + 1):
for k in range(c + 1):
if i*500 + j*100 + k*50 == X:
A += 1
print(A)
| a,b,c,x = [int(eval(input())) for i in range(4)]
ans=0
for a0 in range(a+1):
for b0 in range(b+1):
for c0 in range(c+1):
if (a0*500)+(b0*100)+(c0*50) == x:
ans+=1
print(ans) | 9 | 8 | 216 | 194 | a, b, c, X = [int(eval(input())) for i in range(4)]
A = 0
for i in range(a + 1):
for j in range(b + 1):
for k in range(c + 1):
if i * 500 + j * 100 + k * 50 == X:
A += 1
print(A)
| a, b, c, x = [int(eval(input())) for i in range(4)]
ans = 0
for a0 in range(a + 1):
for b0 in range(b + 1):
for c0 in range(c + 1):
if (a0 * 500) + (b0 * 100) + (c0 * 50) == x:
ans += 1
print(ans)
| false | 11.111111 | [
"-a, b, c, X = [int(eval(input())) for i in range(4)]",
"-A = 0",
"-for i in range(a + 1):",
"- for j in range(b + 1):",
"- for k in range(c + 1):",
"- if i * 500 + j * 100 + k * 50 == X:",
"- A += 1",
"-print(A)",
"+a, b, c, x = [int(eval(input())) for i in range(4)]",
"+ans = 0",
"+for a0 in range(a + 1):",
"+ for b0 in range(b + 1):",
"+ for c0 in range(c + 1):",
"+ if (a0 * 500) + (b0 * 100) + (c0 * 50) == x:",
"+ ans += 1",
"+print(ans)"
]
| false | 0.070301 | 0.246697 | 0.284968 | [
"s781173779",
"s838841975"
]
|
u499381410 | p03612 | python | s420520107 | s458903407 | 228 | 204 | 53,264 | 53,232 | Accepted | Accepted | 10.53 | from collections import defaultdict, deque
from heapq import heappush, heappop, heapify
import math
import bisect
import random
import sys
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LIM(): return list([int(x) - 1 for x in sys.stdin.readline().split()])
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline()
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def LIRM(n): return [LIM() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
mod = 1000000007
n = I()
nums = LI()
cnt = 0
ans = 0
for i in range(n):
if nums[i] == i + 1:
cnt += 1
else:
if cnt:
ans += (cnt + 1) // 2
cnt = 0
if cnt:
ans += (cnt + 1) // 2
print(ans)
| from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor, atan2
from operator import mul
from functools import reduce
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 10 ** 9 + 7
n = I()
L = LI() + [-1]
ans = 0
cnt = 0
for i in range(n + 1):
if L[i] == i + 1:
cnt += 1
else:
ans += (cnt + 1) // 2
cnt = 0
print(ans) | 40 | 41 | 906 | 1,209 | from collections import defaultdict, deque
from heapq import heappush, heappop, heapify
import math
import bisect
import random
import sys
def LI():
return list(map(int, sys.stdin.readline().split()))
def I():
return int(sys.stdin.readline())
def LIM():
return list([int(x) - 1 for x in sys.stdin.readline().split()])
def LS():
return sys.stdin.readline().split()
def S():
return sys.stdin.readline()
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def LIRM(n):
return [LIM() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
mod = 1000000007
n = I()
nums = LI()
cnt = 0
ans = 0
for i in range(n):
if nums[i] == i + 1:
cnt += 1
else:
if cnt:
ans += (cnt + 1) // 2
cnt = 0
if cnt:
ans += (cnt + 1) // 2
print(ans)
| from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor, atan2
from operator import mul
from functools import reduce
sys.setrecursionlimit(10**9)
INF = 10**20
def LI():
return list(map(int, sys.stdin.buffer.readline().split()))
def I():
return int(sys.stdin.buffer.readline())
def LS():
return sys.stdin.buffer.readline().rstrip().decode("utf-8").split()
def S():
return sys.stdin.buffer.readline().rstrip().decode("utf-8")
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
def SRL(n):
return [list(S()) for i in range(n)]
def MSRL(n):
return [[int(j) for j in list(S())] for i in range(n)]
mod = 10**9 + 7
n = I()
L = LI() + [-1]
ans = 0
cnt = 0
for i in range(n + 1):
if L[i] == i + 1:
cnt += 1
else:
ans += (cnt + 1) // 2
cnt = 0
print(ans)
| false | 2.439024 | [
"-from collections import defaultdict, deque",
"+from collections import defaultdict, deque, Counter",
"+from itertools import permutations, accumulate, combinations, product",
"+import string",
"+from bisect import bisect_left, bisect_right",
"+from math import factorial, ceil, floor, atan2",
"+from operator import mul",
"+from functools import reduce",
"+",
"+sys.setrecursionlimit(10**9)",
"+INF = 10**20",
"- return list(map(int, sys.stdin.readline().split()))",
"+ return list(map(int, sys.stdin.buffer.readline().split()))",
"- return int(sys.stdin.readline())",
"-",
"-",
"-def LIM():",
"- return list([int(x) - 1 for x in sys.stdin.readline().split()])",
"+ return int(sys.stdin.buffer.readline())",
"- return sys.stdin.readline().split()",
"+ return sys.stdin.buffer.readline().rstrip().decode(\"utf-8\").split()",
"- return sys.stdin.readline()",
"+ return sys.stdin.buffer.readline().rstrip().decode(\"utf-8\")",
"-def LIRM(n):",
"- return [LIM() for i in range(n)]",
"-",
"-",
"-mod = 1000000007",
"+def SRL(n):",
"+ return [list(S()) for i in range(n)]",
"+",
"+",
"+def MSRL(n):",
"+ return [[int(j) for j in list(S())] for i in range(n)]",
"+",
"+",
"+mod = 10**9 + 7",
"-nums = LI()",
"+L = LI() + [-1]",
"+ans = 0",
"-ans = 0",
"-for i in range(n):",
"- if nums[i] == i + 1:",
"+for i in range(n + 1):",
"+ if L[i] == i + 1:",
"- if cnt:",
"- ans += (cnt + 1) // 2",
"+ ans += (cnt + 1) // 2",
"-if cnt:",
"- ans += (cnt + 1) // 2"
]
| false | 0.090546 | 0.046957 | 1.92826 | [
"s420520107",
"s458903407"
]
|
u941753895 | p03965 | python | s043675944 | s343718648 | 68 | 41 | 6,696 | 5,672 | Accepted | Accepted | 39.71 | import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time
sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
def LI(): return list(map(int,input().split()))
def I(): return int(eval(input()))
def LS(): return input().split()
def S(): return eval(input())
def main():
s=S()
gc=0
pc=0
p=0
for x in s:
if gc<pc+1:
gc+=1
if x=='p':
p-=1
else:
pc+=1
if x=='g':
p+=1
return p
print((main()))
| import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time
sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
def LI(): return list(map(int,input().split()))
def I(): return int(eval(input()))
def LS(): return input().split()
def S(): return eval(input())
# 方針
# なるべくパーを出した方がいい
# len(s)の半分をパーにすれば条件は満たされる
# あとはポイントを計算する
# （自分のパーの数） - （相手のパーの数）
def main():
s=S()
g=s.count('g')
p=len(s)-g
myp=len(s)//2
myg=len(s)-myp
return myp-p
print((main()))
| 33 | 29 | 511 | 511 | import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time
sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7
def LI():
return list(map(int, input().split()))
def I():
return int(eval(input()))
def LS():
return input().split()
def S():
return eval(input())
def main():
s = S()
gc = 0
pc = 0
p = 0
for x in s:
if gc < pc + 1:
gc += 1
if x == "p":
p -= 1
else:
pc += 1
if x == "g":
p += 1
return p
print((main()))
| import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time
sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7
def LI():
return list(map(int, input().split()))
def I():
return int(eval(input()))
def LS():
return input().split()
def S():
return eval(input())
# 方針
# なるべくパーを出した方がいい
# len(s)の半分をパーにすれば条件は満たされる
# あとはポイントを計算する
# （自分のパーの数） - （相手のパーの数）
def main():
s = S()
g = s.count("g")
p = len(s) - g
myp = len(s) // 2
myg = len(s) - myp
return myp - p
print((main()))
| false | 12.121212 | [
"+# 方針",
"+# なるべくパーを出した方がいい",
"+# len(s)の半分をパーにすれば条件は満たされる",
"+# あとはポイントを計算する",
"+# （自分のパーの数） - （相手のパーの数）",
"- gc = 0",
"- pc = 0",
"- p = 0",
"- for x in s:",
"- if gc < pc + 1:",
"- gc += 1",
"- if x == \"p\":",
"- p -= 1",
"- else:",
"- pc += 1",
"- if x == \"g\":",
"- p += 1",
"- return p",
"+ g = s.count(\"g\")",
"+ p = len(s) - g",
"+ myp = len(s) // 2",
"+ myg = len(s) - myp",
"+ return myp - p"
]
| false | 0.042545 | 0.042988 | 0.989694 | [
"s043675944",
"s343718648"
]
|
u762540523 | p02819 | python | s951715114 | s221477944 | 278 | 195 | 47,452 | 39,152 | Accepted | Accepted | 29.86 | def miller_rabin(n, k=10000):
import random
if n == 2:
return True
if n == 1 or n & 1 == 0:
return False
d = (n - 1) >> 1
while d & 1 == 0:
d >>= 1
for _ in range(k):
a = random.randint(1, n - 1)
t = d
y = pow(a, t, n)
while t != n - 1 and y != 1 and y != n - 1:
y = (y * y) % n
t <<= 1
if y != n - 1 and t & 1 == 0:
return False
return True
def main():
x=int(eval(input()))
for i in range(x,1000000):
if miller_rabin(i):
print(i)
return
main() | def miller_rabin(n, k=100):
import random
if n == 2:
return True
if n == 1 or n & 1 == 0:
return False
d = (n - 1) >> 1
while d & 1 == 0:
d >>= 1
for _ in range(k):
a = random.randint(1, n - 1)
t = d
y = pow(a, t, n)
while t != n - 1 and y != 1 and y != n - 1:
y = (y * y) % n
t <<= 1
if y != n - 1 and t & 1 == 0:
return False
return True
def main():
x=int(eval(input()))
for i in range(x,1000000):
if miller_rabin(i):
print(i)
return
main() | 26 | 26 | 611 | 609 | def miller_rabin(n, k=10000):
import random
if n == 2:
return True
if n == 1 or n & 1 == 0:
return False
d = (n - 1) >> 1
while d & 1 == 0:
d >>= 1
for _ in range(k):
a = random.randint(1, n - 1)
t = d
y = pow(a, t, n)
while t != n - 1 and y != 1 and y != n - 1:
y = (y * y) % n
t <<= 1
if y != n - 1 and t & 1 == 0:
return False
return True
def main():
x = int(eval(input()))
for i in range(x, 1000000):
if miller_rabin(i):
print(i)
return
main()
| def miller_rabin(n, k=100):
import random
if n == 2:
return True
if n == 1 or n & 1 == 0:
return False
d = (n - 1) >> 1
while d & 1 == 0:
d >>= 1
for _ in range(k):
a = random.randint(1, n - 1)
t = d
y = pow(a, t, n)
while t != n - 1 and y != 1 and y != n - 1:
y = (y * y) % n
t <<= 1
if y != n - 1 and t & 1 == 0:
return False
return True
def main():
x = int(eval(input()))
for i in range(x, 1000000):
if miller_rabin(i):
print(i)
return
main()
| false | 0 | [
"-def miller_rabin(n, k=10000):",
"+def miller_rabin(n, k=100):"
]
| false | 0.079564 | 0.045981 | 1.730384 | [
"s951715114",
"s221477944"
]
|
u644907318 | p03419 | python | s381386374 | s644136144 | 175 | 76 | 38,384 | 61,692 | Accepted | Accepted | 56.57 | N,M = list(map(int,input().split()))
if N==1 and M==1:
ans = 1
elif N==1 or M==1:
ans = max(N-2,M-2)
elif N==2 or M==2:
ans = 0
else:
ans = N*M-2*(N+M-2)
print(ans) | N,M = list(map(int,input().split()))
if N==1 and M==1:
print((1))
elif N==1 and M>1:
print((M-2))
elif N>1 and M==1:
print((N-2))
else:
print(((N-2)*(M-2))) | 10 | 9 | 183 | 166 | N, M = list(map(int, input().split()))
if N == 1 and M == 1:
ans = 1
elif N == 1 or M == 1:
ans = max(N - 2, M - 2)
elif N == 2 or M == 2:
ans = 0
else:
ans = N * M - 2 * (N + M - 2)
print(ans)
| N, M = list(map(int, input().split()))
if N == 1 and M == 1:
print((1))
elif N == 1 and M > 1:
print((M - 2))
elif N > 1 and M == 1:
print((N - 2))
else:
print(((N - 2) * (M - 2)))
| false | 10 | [
"- ans = 1",
"-elif N == 1 or M == 1:",
"- ans = max(N - 2, M - 2)",
"-elif N == 2 or M == 2:",
"- ans = 0",
"+ print((1))",
"+elif N == 1 and M > 1:",
"+ print((M - 2))",
"+elif N > 1 and M == 1:",
"+ print((N - 2))",
"- ans = N * M - 2 * (N + M - 2)",
"-print(ans)",
"+ print(((N - 2) * (M - 2)))"
]
| false | 0.061253 | 0.043375 | 1.412167 | [
"s381386374",
"s644136144"
]
|
u411203878 | p02726 | python | s709182157 | s753844772 | 444 | 254 | 46,668 | 76,044 | Accepted | Accepted | 42.79 | n,x,y = list(map(int,input().split()))
root = [[] for i in range(n)]
for i in range(1,n):
root[i-1].append(i)
root[i].append(i-1)
root[x-1].append(y-1)
root[y-1].append(x-1)
memo = [0]*(n-1)
for j in range(n):
stack=[j]
check = [-1]*n
check[j] = 0
while len(stack):
v = stack.pop(0)
for i in root[v]:
if check[i] == -1:
check[i]=check[v]+1
memo[check[i]-1]+=1
stack.append(i)
for i in memo:
print((i//2)) | from collections import deque
n,x,y = list(map(int,input().split()))
root = [[] for i in range(n)]
for i in range(1,n):
root[i-1].append(i)
root[i].append(i-1)
root[x-1].append(y-1)
root[y-1].append(x-1)
reselt = [0]*(n-1)
for i in range(n):
stack=deque([i])
check = [-1]*n
check[i] = 0
while len(stack)>0:
v = stack.popleft()
for i in root[v]:
if check[i] == -1:
check[i] = check[v]+1
reselt[check[i]-1] += 1
stack.append(i)
for i in reselt:
print((i//2)) | 22 | 29 | 523 | 590 | n, x, y = list(map(int, input().split()))
root = [[] for i in range(n)]
for i in range(1, n):
root[i - 1].append(i)
root[i].append(i - 1)
root[x - 1].append(y - 1)
root[y - 1].append(x - 1)
memo = [0] * (n - 1)
for j in range(n):
stack = [j]
check = [-1] * n
check[j] = 0
while len(stack):
v = stack.pop(0)
for i in root[v]:
if check[i] == -1:
check[i] = check[v] + 1
memo[check[i] - 1] += 1
stack.append(i)
for i in memo:
print((i // 2))
| from collections import deque
n, x, y = list(map(int, input().split()))
root = [[] for i in range(n)]
for i in range(1, n):
root[i - 1].append(i)
root[i].append(i - 1)
root[x - 1].append(y - 1)
root[y - 1].append(x - 1)
reselt = [0] * (n - 1)
for i in range(n):
stack = deque([i])
check = [-1] * n
check[i] = 0
while len(stack) > 0:
v = stack.popleft()
for i in root[v]:
if check[i] == -1:
check[i] = check[v] + 1
reselt[check[i] - 1] += 1
stack.append(i)
for i in reselt:
print((i // 2))
| false | 24.137931 | [
"+from collections import deque",
"+",
"-memo = [0] * (n - 1)",
"-for j in range(n):",
"- stack = [j]",
"+reselt = [0] * (n - 1)",
"+for i in range(n):",
"+ stack = deque([i])",
"- check[j] = 0",
"- while len(stack):",
"- v = stack.pop(0)",
"+ check[i] = 0",
"+ while len(stack) > 0:",
"+ v = stack.popleft()",
"- memo[check[i] - 1] += 1",
"+ reselt[check[i] - 1] += 1",
"-for i in memo:",
"+for i in reselt:"
]
| false | 0.037018 | 0.037385 | 0.990166 | [
"s709182157",
"s753844772"
]
|
u284854859 | p03602 | python | s522647357 | s396630460 | 1,496 | 1,141 | 96,892 | 56,668 | Accepted | Accepted | 23.73 | def warshall_floyd(n,d):
#d[i][j]: iからjへの最短距離
r = [[float("inf")]*n for i in range(n)]
for k in range(n):
for i in range(n):
for j in range(n):
r[i][j] = min(d[i][j],r[i][k] + r[k][j])
return r
n = int(eval(input()))
a = [[] for i in range(n)]
for i in range(n):
a[i] = list(map(int,input().split()))
for i in range(n):
if a[i][i] != 0:
print((-1))
exit()
war = warshall_floyd(n,a)
res = 0
for i in range(n):
for j in range(n):
if war[i][j] < a[i][j]:
print((-1))
exit()
elif war[i][j] == a[i][j]:
judge = 1
for h in range(n):
if h != i and h != j and war[i][h]+war[h][j] == war[i][j]:
judge = -1
if judge == 1:
res += war[i][j]
print((res//2))
| import copy
def warshall_floyd(d):
#d[i][j]: iからjへの最短距離
for k in range(n):
for i in range(n):
for j in range(n):
d[i][j] = min(d[i][j],d[i][k] + d[k][j])
n = int(eval(input()))
a = [[] for i in range(n)]
war = [[] for i in range(n)]
for i in range(n):
a[i] = list(map(int,input().split()))
war = copy.deepcopy(a)
for i in range(n):
if a[i][i] != 0:
print((-1))
exit()
warshall_floyd(war)
res = 0
for i in range(n):
for j in range(n):
if war[i][j] < a[i][j]:
print((-1))
exit()
elif war[i][j] == a[i][j]:
judge = 1
for h in range(n):
if h != i and h != j and war[i][h]+war[h][j] == war[i][j]:
judge = -1
if judge == 1:
res += war[i][j]
print((res//2)) | 35 | 36 | 879 | 879 | def warshall_floyd(n, d):
# d[i][j]: iからjへの最短距離
r = [[float("inf")] * n for i in range(n)]
for k in range(n):
for i in range(n):
for j in range(n):
r[i][j] = min(d[i][j], r[i][k] + r[k][j])
return r
n = int(eval(input()))
a = [[] for i in range(n)]
for i in range(n):
a[i] = list(map(int, input().split()))
for i in range(n):
if a[i][i] != 0:
print((-1))
exit()
war = warshall_floyd(n, a)
res = 0
for i in range(n):
for j in range(n):
if war[i][j] < a[i][j]:
print((-1))
exit()
elif war[i][j] == a[i][j]:
judge = 1
for h in range(n):
if h != i and h != j and war[i][h] + war[h][j] == war[i][j]:
judge = -1
if judge == 1:
res += war[i][j]
print((res // 2))
| import copy
def warshall_floyd(d):
# d[i][j]: iからjへの最短距離
for k in range(n):
for i in range(n):
for j in range(n):
d[i][j] = min(d[i][j], d[i][k] + d[k][j])
n = int(eval(input()))
a = [[] for i in range(n)]
war = [[] for i in range(n)]
for i in range(n):
a[i] = list(map(int, input().split()))
war = copy.deepcopy(a)
for i in range(n):
if a[i][i] != 0:
print((-1))
exit()
warshall_floyd(war)
res = 0
for i in range(n):
for j in range(n):
if war[i][j] < a[i][j]:
print((-1))
exit()
elif war[i][j] == a[i][j]:
judge = 1
for h in range(n):
if h != i and h != j and war[i][h] + war[h][j] == war[i][j]:
judge = -1
if judge == 1:
res += war[i][j]
print((res // 2))
| false | 2.777778 | [
"-def warshall_floyd(n, d):",
"+import copy",
"+",
"+",
"+def warshall_floyd(d):",
"- r = [[float(\"inf\")] * n for i in range(n)]",
"- r[i][j] = min(d[i][j], r[i][k] + r[k][j])",
"- return r",
"+ d[i][j] = min(d[i][j], d[i][k] + d[k][j])",
"+war = [[] for i in range(n)]",
"+war = copy.deepcopy(a)",
"-war = warshall_floyd(n, a)",
"+warshall_floyd(war)"
]
| false | 0.046154 | 0.047965 | 0.962236 | [
"s522647357",
"s396630460"
]
|
u509278866 | p01812 | python | s725688188 | s181126474 | 9,550 | 4,870 | 15,204 | 11,340 | Accepted | Accepted | 49.01 | import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(0,-1),(1,0),(0,1),(-1,0)]
ddn = [(0,-1),(1,-1),(1,0),(1,1),(0,1),(-1,-1),(-1,0),(-1,1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def main():
n,m,k = LI()
d = LI_()
v = [LI_() for _ in range(n)]
dd = collections.defaultdict(lambda: None)
for i in range(m):
dd[d[i]] = i
vv = []
for c in d:
vv.append([dd[v[c][i]] for i in range(k)])
vvv = [[vv[i][j] for i in range(m)] for j in range(k)]
u = set()
m2 = 2**m
u.add(m2-1)
q = [(m2-1, 1)]
ii = [2**_ for _ in range(m)]
# print('vv',vv)
while q:
qd, qk = q.pop(0)
# print('q', qd,qk)
qdi = [di for di in range(m) if qd & ii[di]]
for vi in range(k):
t = 0
vvi = vvv[vi]
for di in qdi:
if not vvi[di] is None:
t |= ii[vvi[di]]
# print('vit',vi,t)
if t in u:
continue
if t == 0:
return qk
u.add(t)
q.append((t,qk+1))
return -1
print(main())
| import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(0,-1),(1,0),(0,1),(-1,0)]
ddn = [(0,-1),(1,-1),(1,0),(1,1),(0,1),(-1,-1),(-1,0),(-1,1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def main():
n,m,k = LI()
d = LI_()
v = [LI_() for _ in range(n)]
dd = collections.defaultdict(lambda: None)
for i in range(m):
dd[d[i]] = i
ii = [2**_ for _ in range(m)]
vv = [[ii[dd[v[c][i]]] if not dd[v[c][i]] is None else 0 for c in d] for i in range(k)]
m2 = 2**m
u = [None] * m2
u[-1] = 1
q = [m2-1]
r = 0
while q:
r += 1
nq = []
for qd in q:
qdi = [di for di in range(m) if qd & ii[di]]
for vi in range(k):
t = 0
vvi = vv[vi]
for di in qdi:
t |= vvi[di]
if not u[t] is None:
continue
if t == 0:
return r
u[t] = 1
nq.append(t)
q = nq
return -1
print(main())
| 60 | 56 | 1,664 | 1,585 | import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9 + 7
dd = [(0, -1), (1, 0), (0, 1), (-1, 0)]
ddn = [(0, -1), (1, -1), (1, 0), (1, 1), (0, 1), (-1, -1), (-1, 0), (-1, 1)]
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def LI_():
return [int(x) - 1 for x in sys.stdin.readline().split()]
def LF():
return [float(x) for x in sys.stdin.readline().split()]
def LS():
return sys.stdin.readline().split()
def I():
return int(sys.stdin.readline())
def F():
return float(sys.stdin.readline())
def S():
return input()
def pf(s):
return print(s, flush=True)
def main():
n, m, k = LI()
d = LI_()
v = [LI_() for _ in range(n)]
dd = collections.defaultdict(lambda: None)
for i in range(m):
dd[d[i]] = i
vv = []
for c in d:
vv.append([dd[v[c][i]] for i in range(k)])
vvv = [[vv[i][j] for i in range(m)] for j in range(k)]
u = set()
m2 = 2**m
u.add(m2 - 1)
q = [(m2 - 1, 1)]
ii = [2**_ for _ in range(m)]
# print('vv',vv)
while q:
qd, qk = q.pop(0)
# print('q', qd,qk)
qdi = [di for di in range(m) if qd & ii[di]]
for vi in range(k):
t = 0
vvi = vvv[vi]
for di in qdi:
if not vvi[di] is None:
t |= ii[vvi[di]]
# print('vit',vi,t)
if t in u:
continue
if t == 0:
return qk
u.add(t)
q.append((t, qk + 1))
return -1
print(main())
| import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9 + 7
dd = [(0, -1), (1, 0), (0, 1), (-1, 0)]
ddn = [(0, -1), (1, -1), (1, 0), (1, 1), (0, 1), (-1, -1), (-1, 0), (-1, 1)]
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def LI_():
return [int(x) - 1 for x in sys.stdin.readline().split()]
def LF():
return [float(x) for x in sys.stdin.readline().split()]
def LS():
return sys.stdin.readline().split()
def I():
return int(sys.stdin.readline())
def F():
return float(sys.stdin.readline())
def S():
return input()
def pf(s):
return print(s, flush=True)
def main():
n, m, k = LI()
d = LI_()
v = [LI_() for _ in range(n)]
dd = collections.defaultdict(lambda: None)
for i in range(m):
dd[d[i]] = i
ii = [2**_ for _ in range(m)]
vv = [
[ii[dd[v[c][i]]] if not dd[v[c][i]] is None else 0 for c in d] for i in range(k)
]
m2 = 2**m
u = [None] * m2
u[-1] = 1
q = [m2 - 1]
r = 0
while q:
r += 1
nq = []
for qd in q:
qdi = [di for di in range(m) if qd & ii[di]]
for vi in range(k):
t = 0
vvi = vv[vi]
for di in qdi:
t |= vvi[di]
if not u[t] is None:
continue
if t == 0:
return r
u[t] = 1
nq.append(t)
q = nq
return -1
print(main())
| false | 6.666667 | [
"- vv = []",
"- for c in d:",
"- vv.append([dd[v[c][i]] for i in range(k)])",
"- vvv = [[vv[i][j] for i in range(m)] for j in range(k)]",
"- u = set()",
"+ ii = [2**_ for _ in range(m)]",
"+ vv = [",
"+ [ii[dd[v[c][i]]] if not dd[v[c][i]] is None else 0 for c in d] for i in range(k)",
"+ ]",
"- u.add(m2 - 1)",
"- q = [(m2 - 1, 1)]",
"- ii = [2**_ for _ in range(m)]",
"- # print('vv',vv)",
"+ u = [None] * m2",
"+ u[-1] = 1",
"+ q = [m2 - 1]",
"+ r = 0",
"- qd, qk = q.pop(0)",
"- # print('q', qd,qk)",
"- qdi = [di for di in range(m) if qd & ii[di]]",
"- for vi in range(k):",
"- t = 0",
"- vvi = vvv[vi]",
"- for di in qdi:",
"- if not vvi[di] is None:",
"- t |= ii[vvi[di]]",
"- # print('vit',vi,t)",
"- if t in u:",
"- continue",
"- if t == 0:",
"- return qk",
"- u.add(t)",
"- q.append((t, qk + 1))",
"+ r += 1",
"+ nq = []",
"+ for qd in q:",
"+ qdi = [di for di in range(m) if qd & ii[di]]",
"+ for vi in range(k):",
"+ t = 0",
"+ vvi = vv[vi]",
"+ for di in qdi:",
"+ t |= vvi[di]",
"+ if not u[t] is None:",
"+ continue",
"+ if t == 0:",
"+ return r",
"+ u[t] = 1",
"+ nq.append(t)",
"+ q = nq"
]
| false | 0.089059 | 0.069247 | 1.286101 | [
"s725688188",
"s181126474"
]
|
u855775311 | p02376 | python | s354629092 | s606615353 | 1,080 | 50 | 7,852 | 7,800 | Accepted | Accepted | 95.37 | def main():
nvertices, nedges = list(map(int, input().split()))
adj = [[0 for i in range(nvertices)] for j in range(nvertices)]
for i in range(nedges):
u, v, c = list(map(int, input().split()))
adj[u][v] = c
INF = float('inf')
ans = 0
while True:
parents = bfs(0, nvertices - 1, adj)
if parents is None:
break
v = nvertices - 1
f = INF
while parents[v] != -1:
f = min(f, adj[parents[v]][v])
v = parents[v]
ans += f
v = nvertices - 1
while parents[v] != -1:
adj[parents[v]][v] -= f
adj[v][parents[v]] += f
v = parents[v]
print(ans)
def bfs(s, t, adj):
visited = [False] * len(adj)
que = [s]
parents = [-1] * len(adj)
while que:
u = que.pop(0)
visited[u] = True
if u == t:
return parents
for v in range(len(adj)):
if not visited[v] and adj[u][v] > 0:
parents[v] = u
que.append(v)
return None
main() | def main():
nvertices, nedges = list(map(int, input().split()))
adj = [[0] * nvertices for j in range(nvertices)]
for i in range(nedges):
u, v, c = list(map(int, input().split()))
adj[u][v] = c
INF = float('inf')
ans = 0
while True:
parents = bfs(0, nvertices - 1, adj)
if parents is None:
break
v = nvertices - 1
f = INF
while parents[v] != -1:
f = min(f, adj[parents[v]][v])
v = parents[v]
ans += f
v = nvertices - 1
while v != 0:
u = parents[v]
adj[u][v] -= f
adj[v][u] += f
v = u
print(ans)
def bfs(s, t, adj):
nvertices = len(adj)
visited = [False] * nvertices
visited[0] = True
que = [s]
parents = [-1] * nvertices
while que:
u = que.pop(0)
if u == t:
return parents
for v in range(len(adj)):
if not visited[v] and adj[u][v] > 0:
parents[v] = u
visited[v] = True
que.append(v)
return None
main() | 48 | 51 | 1,128 | 1,164 | def main():
nvertices, nedges = list(map(int, input().split()))
adj = [[0 for i in range(nvertices)] for j in range(nvertices)]
for i in range(nedges):
u, v, c = list(map(int, input().split()))
adj[u][v] = c
INF = float("inf")
ans = 0
while True:
parents = bfs(0, nvertices - 1, adj)
if parents is None:
break
v = nvertices - 1
f = INF
while parents[v] != -1:
f = min(f, adj[parents[v]][v])
v = parents[v]
ans += f
v = nvertices - 1
while parents[v] != -1:
adj[parents[v]][v] -= f
adj[v][parents[v]] += f
v = parents[v]
print(ans)
def bfs(s, t, adj):
visited = [False] * len(adj)
que = [s]
parents = [-1] * len(adj)
while que:
u = que.pop(0)
visited[u] = True
if u == t:
return parents
for v in range(len(adj)):
if not visited[v] and adj[u][v] > 0:
parents[v] = u
que.append(v)
return None
main()
| def main():
nvertices, nedges = list(map(int, input().split()))
adj = [[0] * nvertices for j in range(nvertices)]
for i in range(nedges):
u, v, c = list(map(int, input().split()))
adj[u][v] = c
INF = float("inf")
ans = 0
while True:
parents = bfs(0, nvertices - 1, adj)
if parents is None:
break
v = nvertices - 1
f = INF
while parents[v] != -1:
f = min(f, adj[parents[v]][v])
v = parents[v]
ans += f
v = nvertices - 1
while v != 0:
u = parents[v]
adj[u][v] -= f
adj[v][u] += f
v = u
print(ans)
def bfs(s, t, adj):
nvertices = len(adj)
visited = [False] * nvertices
visited[0] = True
que = [s]
parents = [-1] * nvertices
while que:
u = que.pop(0)
if u == t:
return parents
for v in range(len(adj)):
if not visited[v] and adj[u][v] > 0:
parents[v] = u
visited[v] = True
que.append(v)
return None
main()
| false | 5.882353 | [
"- adj = [[0 for i in range(nvertices)] for j in range(nvertices)]",
"+ adj = [[0] * nvertices for j in range(nvertices)]",
"- while parents[v] != -1:",
"- adj[parents[v]][v] -= f",
"- adj[v][parents[v]] += f",
"- v = parents[v]",
"+ while v != 0:",
"+ u = parents[v]",
"+ adj[u][v] -= f",
"+ adj[v][u] += f",
"+ v = u",
"- visited = [False] * len(adj)",
"+ nvertices = len(adj)",
"+ visited = [False] * nvertices",
"+ visited[0] = True",
"- parents = [-1] * len(adj)",
"+ parents = [-1] * nvertices",
"- visited[u] = True",
"+ visited[v] = True"
]
| false | 0.082819 | 0.03654 | 2.266529 | [
"s354629092",
"s606615353"
]
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.