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
sequence | 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
sequence |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
u131634965 | p03971 | python | s809559702 | s029500845 | 121 | 111 | 4,016 | 4,016 | Accepted | Accepted | 8.26 | n,a,b=list(map(int, input().split()))
s=eval(input())
pass_all=0
pass_foreigner=0
for i in range(n):
if s[i]=='a':
if pass_all<a+b:
pass_all+=1
print("Yes")
else:
print("No")
elif s[i]=='b':
if pass_all<a+b and pass_foreigner<b:
pass_all+=1
pass_foreigner+=1
print("Yes")
else:
print("No")
else:
print("No") | n,a,b=list(map(int, input().split()))
s=eval(input())
pass_all=0
pass_foreigner=0
for i in range(n):
if s[i]=='a' and pass_all<a+b:
pass_all+=1
print("Yes")
elif s[i]=='b' and pass_all<a+b and pass_foreigner<b:
pass_all+=1
pass_foreigner+=1
print("Yes")
else:
print("No") | 23 | 15 | 464 | 334 | n, a, b = list(map(int, input().split()))
s = eval(input())
pass_all = 0
pass_foreigner = 0
for i in range(n):
if s[i] == "a":
if pass_all < a + b:
pass_all += 1
print("Yes")
else:
print("No")
elif s[i] == "b":
if pass_all < a + b and pass_foreigner < b:
pass_all += 1
pass_foreigner += 1
print("Yes")
else:
print("No")
else:
print("No")
| n, a, b = list(map(int, input().split()))
s = eval(input())
pass_all = 0
pass_foreigner = 0
for i in range(n):
if s[i] == "a" and pass_all < a + b:
pass_all += 1
print("Yes")
elif s[i] == "b" and pass_all < a + b and pass_foreigner < b:
pass_all += 1
pass_foreigner += 1
print("Yes")
else:
print("No")
| false | 34.782609 | [
"- if s[i] == \"a\":",
"- if pass_all < a + b:",
"- pass_all += 1",
"- print(\"Yes\")",
"- else:",
"- print(\"No\")",
"- elif s[i] == \"b\":",
"- if pass_all < a + b and pass_foreigner < b:",
"- pass_all += 1",
"- pass_foreigner += 1",
"- print(\"Yes\")",
"- else:",
"- print(\"No\")",
"+ if s[i] == \"a\" and pass_all < a + b:",
"+ pass_all += 1",
"+ print(\"Yes\")",
"+ elif s[i] == \"b\" and pass_all < a + b and pass_foreigner < b:",
"+ pass_all += 1",
"+ pass_foreigner += 1",
"+ print(\"Yes\")"
] | false | 0.064573 | 0.067534 | 0.956156 | [
"s809559702",
"s029500845"
] |
u591808161 | p03475 | python | s809598733 | s134177655 | 195 | 63 | 12,496 | 3,188 | Accepted | Accepted | 67.69 | import sys
input = sys.stdin.readline
import numpy as np
def I(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
n = I()
mylist = tuple(tuple(MI()) for i in range(n-1))
def main(j):
time = 0
for i in range(j,n-1):
c, s, f = mylist[i]
if time < s:
time = s
if (time - s) % f != 0:
time += (f - (time - s) % f) #待ち時間を足す
time += c
print(time)
for i in range(n-1):
main(i)
print((0)) | import sys
input = sys.stdin.readline
def I(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
n = I()
mylist = tuple(tuple(MI()) for i in range(n-1))
def main(j):
time = 0
for i in range(j,n-1):
c, s, f = mylist[i]
if time < s:
time = s
elif (time - s) % f != 0:
time += (f - (time - s) % f) #待ち時間を足す
time += c
print(time)
def main2():
for i in range(n-1):
main(i)
print((0))
main2() | 27 | 25 | 555 | 565 | import sys
input = sys.stdin.readline
import numpy as np
def I():
return int(eval(input()))
def MI():
return list(map(int, input().split()))
def LI():
return list(map(int, input().split()))
n = I()
mylist = tuple(tuple(MI()) for i in range(n - 1))
def main(j):
time = 0
for i in range(j, n - 1):
c, s, f = mylist[i]
if time < s:
time = s
if (time - s) % f != 0:
time += f - (time - s) % f # 待ち時間を足す
time += c
print(time)
for i in range(n - 1):
main(i)
print((0))
| import sys
input = sys.stdin.readline
def I():
return int(eval(input()))
def MI():
return list(map(int, input().split()))
def LI():
return list(map(int, input().split()))
n = I()
mylist = tuple(tuple(MI()) for i in range(n - 1))
def main(j):
time = 0
for i in range(j, n - 1):
c, s, f = mylist[i]
if time < s:
time = s
elif (time - s) % f != 0:
time += f - (time - s) % f # 待ち時間を足す
time += c
print(time)
def main2():
for i in range(n - 1):
main(i)
print((0))
main2()
| false | 7.407407 | [
"-import numpy as np",
"- if (time - s) % f != 0:",
"+ elif (time - s) % f != 0:",
"-for i in range(n - 1):",
"- main(i)",
"-print((0))",
"+def main2():",
"+ for i in range(n - 1):",
"+ main(i)",
"+ print((0))",
"+",
"+",
"+main2()"
] | false | 0.083283 | 0.035587 | 2.340277 | [
"s809598733",
"s134177655"
] |
u416011173 | p02583 | python | s370337449 | s544257618 | 109 | 82 | 8,824 | 9,220 | Accepted | Accepted | 24.77 | # -*- coding: utf-8 -*-
# モジュールのインポート
import itertools
# 標準入力を取得
N = int(eval(input()))
L = list(map(int, input().split()))
# 求解処理
ans = 0
for L_i, L_j, L_k in itertools.combinations(L, 3):
if (L_i == L_j) or (L_j == L_k) or (L_k == L_i):
continue
if L_i + L_j + L_k > 2 * max(L_i, L_j, L_k):
ans += 1
# 結果出力
print(ans)
| # -*- coding: utf-8 -*-
# モジュールのインポート
import itertools
def get_input() -> tuple:
"""
標準入力を取得する.
Returns:\n
tuple: 標準入力
"""
N = int(eval(input()))
L = list(map(int, input().split()))
return N, L
def main(L: list) -> None:
"""
メイン処理.
Args:\n
L (list): 棒の長さ
"""
# 求解処理
ans = 0
for L_i, L_j, L_k in itertools.combinations(L, 3):
if (L_i == L_j) or (L_j == L_k) or (L_k == L_i):
continue
if L_i + L_j + L_k > 2 * max(L_i, L_j, L_k):
ans += 1
# 結果出力
print(ans)
if __name__ == "__main__":
# 標準入力を取得
N, L = get_input()
# メイン処理
main(L)
| 18 | 43 | 358 | 710 | # -*- coding: utf-8 -*-
# モジュールのインポート
import itertools
# 標準入力を取得
N = int(eval(input()))
L = list(map(int, input().split()))
# 求解処理
ans = 0
for L_i, L_j, L_k in itertools.combinations(L, 3):
if (L_i == L_j) or (L_j == L_k) or (L_k == L_i):
continue
if L_i + L_j + L_k > 2 * max(L_i, L_j, L_k):
ans += 1
# 結果出力
print(ans)
| # -*- coding: utf-8 -*-
# モジュールのインポート
import itertools
def get_input() -> tuple:
"""
標準入力を取得する.
Returns:\n
tuple: 標準入力
"""
N = int(eval(input()))
L = list(map(int, input().split()))
return N, L
def main(L: list) -> None:
"""
メイン処理.
Args:\n
L (list): 棒の長さ
"""
# 求解処理
ans = 0
for L_i, L_j, L_k in itertools.combinations(L, 3):
if (L_i == L_j) or (L_j == L_k) or (L_k == L_i):
continue
if L_i + L_j + L_k > 2 * max(L_i, L_j, L_k):
ans += 1
# 結果出力
print(ans)
if __name__ == "__main__":
# 標準入力を取得
N, L = get_input()
# メイン処理
main(L)
| false | 58.139535 | [
"-# 標準入力を取得",
"-N = int(eval(input()))",
"-L = list(map(int, input().split()))",
"-# 求解処理",
"-ans = 0",
"-for L_i, L_j, L_k in itertools.combinations(L, 3):",
"- if (L_i == L_j) or (L_j == L_k) or (L_k == L_i):",
"- continue",
"- if L_i + L_j + L_k > 2 * max(L_i, L_j, L_k):",
"- ans += 1",
"-# 結果出力",
"-print(ans)",
"+",
"+def get_input() -> tuple:",
"+ \"\"\"",
"+ 標準入力を取得する.",
"+ Returns:\\n",
"+ tuple: 標準入力",
"+ \"\"\"",
"+ N = int(eval(input()))",
"+ L = list(map(int, input().split()))",
"+ return N, L",
"+",
"+",
"+def main(L: list) -> None:",
"+ \"\"\"",
"+ メイン処理.",
"+ Args:\\n",
"+ L (list): 棒の長さ",
"+ \"\"\"",
"+ # 求解処理",
"+ ans = 0",
"+ for L_i, L_j, L_k in itertools.combinations(L, 3):",
"+ if (L_i == L_j) or (L_j == L_k) or (L_k == L_i):",
"+ continue",
"+ if L_i + L_j + L_k > 2 * max(L_i, L_j, L_k):",
"+ ans += 1",
"+ # 結果出力",
"+ print(ans)",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ # 標準入力を取得",
"+ N, L = get_input()",
"+ # メイン処理",
"+ main(L)"
] | false | 0.073762 | 0.0677 | 1.089552 | [
"s370337449",
"s544257618"
] |
u347640436 | p02715 | python | s580584046 | s013989221 | 164 | 150 | 9,220 | 9,184 | Accepted | Accepted | 8.54 | N, K = list(map(int, input().split()))
MOD = 10 ** 9 + 7
cache = {}
def f(k, n):
if k == 1:
return 1
if k in cache:
return cache[k]
result = pow(k, n, MOD)
for i in range(2, k + 1):
result -= f(k // i, n)
result %= MOD
cache[k] = result
return result
result = 0
for i in range(1, K + 1):
result += f(K // i, N) * i
result %= MOD
print(result)
| N, K = list(map(int, input().split()))
MOD = 10 ** 9 + 7
cache = {}
def f(k, n):
if k == 1:
return 1
if k in cache:
return cache[k]
result = pow(k, n, MOD)
for i in range(2, k + 1):
result -= f(k // i, n)
result %= MOD
cache[k] = result
return result
print((sum(f(K // i, N) * i for i in range(1, K + 1)) % MOD))
| 23 | 19 | 427 | 383 | N, K = list(map(int, input().split()))
MOD = 10**9 + 7
cache = {}
def f(k, n):
if k == 1:
return 1
if k in cache:
return cache[k]
result = pow(k, n, MOD)
for i in range(2, k + 1):
result -= f(k // i, n)
result %= MOD
cache[k] = result
return result
result = 0
for i in range(1, K + 1):
result += f(K // i, N) * i
result %= MOD
print(result)
| N, K = list(map(int, input().split()))
MOD = 10**9 + 7
cache = {}
def f(k, n):
if k == 1:
return 1
if k in cache:
return cache[k]
result = pow(k, n, MOD)
for i in range(2, k + 1):
result -= f(k // i, n)
result %= MOD
cache[k] = result
return result
print((sum(f(K // i, N) * i for i in range(1, K + 1)) % MOD))
| false | 17.391304 | [
"-result = 0",
"-for i in range(1, K + 1):",
"- result += f(K // i, N) * i",
"- result %= MOD",
"-print(result)",
"+print((sum(f(K // i, N) * i for i in range(1, K + 1)) % MOD))"
] | false | 0.108983 | 0.101401 | 1.074775 | [
"s580584046",
"s013989221"
] |
u190850294 | p03147 | python | s144802747 | s571526205 | 32 | 29 | 9,388 | 9,224 | Accepted | Accepted | 9.38 | import sys
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()
hl = LI()
wl = []
count = 0
len_h = len(hl)
def m1(n):
if n > 0:
n = n - 1
else:
n = 0
return n
max_hana = max(hl)
if max_hana == 0:
print((0))
sys.exit()
for i in range(max_hana):
for j in range(len_h):
if j == 0:
if hl[j] > 0:
count += 1
else:
if hl[j] > 0 and hl[j-1] == 0:
count += 1
elif hl[j] > 0 and hl[j-1] == 0:
count += 1
hl = list(map(m1, hl))
print(count) | import sys
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()
hl = LI()
# count = 0
# len_h = len(hl)
# def m1(n):
# if n > 0:
# n = n - 1
# else:
# n = 0
# return n
# max_hana = max(hl)
# if max_hana == 0:
# print(0)
# sys.exit()
# for i in range(max_hana):
# for j in range(len_h):
# if j == 0:
# if hl[j] > 0:
# count += 1
# else:
# if hl[j] > 0 and hl[j-1] == 0:
# count += 1
# elif hl[j] > 0 and hl[j-1] == 0:
# count += 1
# hl = list(map(m1, hl))
# print(count)
######################
# 隣との差分を考えたほうが早い
# 1 2 4 2 1 0 計4
# 1 2 0 0 0
ans = hl[0]
for i in range(1, n):
ans += max(0, hl[i] - hl[i - 1])
print(ans)
| 45 | 56 | 1,150 | 1,392 | import sys
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()
hl = LI()
wl = []
count = 0
len_h = len(hl)
def m1(n):
if n > 0:
n = n - 1
else:
n = 0
return n
max_hana = max(hl)
if max_hana == 0:
print((0))
sys.exit()
for i in range(max_hana):
for j in range(len_h):
if j == 0:
if hl[j] > 0:
count += 1
else:
if hl[j] > 0 and hl[j - 1] == 0:
count += 1
elif hl[j] > 0 and hl[j - 1] == 0:
count += 1
hl = list(map(m1, hl))
print(count)
| import sys
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()
hl = LI()
# count = 0
# len_h = len(hl)
# def m1(n):
# if n > 0:
# n = n - 1
# else:
# n = 0
# return n
# max_hana = max(hl)
# if max_hana == 0:
# print(0)
# sys.exit()
# for i in range(max_hana):
# for j in range(len_h):
# if j == 0:
# if hl[j] > 0:
# count += 1
# else:
# if hl[j] > 0 and hl[j-1] == 0:
# count += 1
# elif hl[j] > 0 and hl[j-1] == 0:
# count += 1
# hl = list(map(m1, hl))
# print(count)
######################
# 隣との差分を考えたほうが早い
# 1 2 4 2 1 0 計4
# 1 2 0 0 0
ans = hl[0]
for i in range(1, n):
ans += max(0, hl[i] - hl[i - 1])
print(ans)
| false | 19.642857 | [
"-wl = []",
"-count = 0",
"-len_h = len(hl)",
"-",
"-",
"-def m1(n):",
"- if n > 0:",
"- n = n - 1",
"- else:",
"- n = 0",
"- return n",
"-",
"-",
"-max_hana = max(hl)",
"-if max_hana == 0:",
"- print((0))",
"- sys.exit()",
"-for i in range(max_hana):",
"- for j in range(len_h):",
"- if j == 0:",
"- if hl[j] > 0:",
"- count += 1",
"- else:",
"- if hl[j] > 0 and hl[j - 1] == 0:",
"- count += 1",
"- elif hl[j] > 0 and hl[j - 1] == 0:",
"- count += 1",
"- hl = list(map(m1, hl))",
"-print(count)",
"+# count = 0",
"+# len_h = len(hl)",
"+# def m1(n):",
"+# if n > 0:",
"+# n = n - 1",
"+# else:",
"+# n = 0",
"+# return n",
"+# max_hana = max(hl)",
"+# if max_hana == 0:",
"+# print(0)",
"+# sys.exit()",
"+# for i in range(max_hana):",
"+# for j in range(len_h):",
"+# if j == 0:",
"+# if hl[j] > 0:",
"+# count += 1",
"+# else:",
"+# if hl[j] > 0 and hl[j-1] == 0:",
"+# count += 1",
"+# elif hl[j] > 0 and hl[j-1] == 0:",
"+# count += 1",
"+# hl = list(map(m1, hl))",
"+# print(count)",
"+######################",
"+# 隣との差分を考えたほうが早い",
"+# 1 2 4 2 1 0 計4",
"+# 1 2 0 0 0",
"+ans = hl[0]",
"+for i in range(1, n):",
"+ ans += max(0, hl[i] - hl[i - 1])",
"+print(ans)"
] | false | 0.049866 | 0.046865 | 1.064023 | [
"s144802747",
"s571526205"
] |
u898967808 | p02695 | python | s384251488 | s352284785 | 1,185 | 805 | 9,152 | 9,248 | Accepted | Accepted | 32.07 | from itertools import combinations_with_replacement
n,m,q = list(map(int,input().split()))
a=[0]*q
b=[0]*q
c=[0]*q
d=[0]*q
for i in range(q):
a[i],b[i],c[i],d[i] = list(map(int,input().split()))
ans = 0
for cmb in combinations_with_replacement(list(range(1,m+1)),n):
tmp = 0
for i in range(q):
if cmb[b[i]-1] - cmb[a[i]-1] == c[i]:
tmp += d[i]
ans = max(ans,tmp)
print(ans) | from itertools import combinations_with_replacement
n,m,q = list(map(int,input().split()))
a=[0]*q
b=[0]*q
c=[0]*q
d=[0]*q
for i in range(q):
a[i],b[i],c[i],d[i] = list(map(int,input().split()))
ans = 0
def dfs(A):
global ans
if len(A) >= n:
tmp = 0
for i in range(q):
if A[b[i]-1] - A[a[i]-1] == c[i]:
tmp += d[i]
ans = max(ans,tmp)
else:
s = 1
if len(A)>0:
s = A[-1]
for i in range(s-1,m):
dfs(A+[i+1])
A = []
dfs(A)
print(ans) | 19 | 28 | 402 | 521 | from itertools import combinations_with_replacement
n, m, q = list(map(int, input().split()))
a = [0] * q
b = [0] * q
c = [0] * q
d = [0] * q
for i in range(q):
a[i], b[i], c[i], d[i] = list(map(int, input().split()))
ans = 0
for cmb in combinations_with_replacement(list(range(1, m + 1)), n):
tmp = 0
for i in range(q):
if cmb[b[i] - 1] - cmb[a[i] - 1] == c[i]:
tmp += d[i]
ans = max(ans, tmp)
print(ans)
| from itertools import combinations_with_replacement
n, m, q = list(map(int, input().split()))
a = [0] * q
b = [0] * q
c = [0] * q
d = [0] * q
for i in range(q):
a[i], b[i], c[i], d[i] = list(map(int, input().split()))
ans = 0
def dfs(A):
global ans
if len(A) >= n:
tmp = 0
for i in range(q):
if A[b[i] - 1] - A[a[i] - 1] == c[i]:
tmp += d[i]
ans = max(ans, tmp)
else:
s = 1
if len(A) > 0:
s = A[-1]
for i in range(s - 1, m):
dfs(A + [i + 1])
A = []
dfs(A)
print(ans)
| false | 32.142857 | [
"-for cmb in combinations_with_replacement(list(range(1, m + 1)), n):",
"- tmp = 0",
"- for i in range(q):",
"- if cmb[b[i] - 1] - cmb[a[i] - 1] == c[i]:",
"- tmp += d[i]",
"- ans = max(ans, tmp)",
"+",
"+",
"+def dfs(A):",
"+ global ans",
"+ if len(A) >= n:",
"+ tmp = 0",
"+ for i in range(q):",
"+ if A[b[i] - 1] - A[a[i] - 1] == c[i]:",
"+ tmp += d[i]",
"+ ans = max(ans, tmp)",
"+ else:",
"+ s = 1",
"+ if len(A) > 0:",
"+ s = A[-1]",
"+ for i in range(s - 1, m):",
"+ dfs(A + [i + 1])",
"+",
"+",
"+A = []",
"+dfs(A)"
] | false | 0.045429 | 0.072153 | 0.629615 | [
"s384251488",
"s352284785"
] |
u752906728 | p03447 | python | s253233461 | s063451933 | 918 | 818 | 3,056 | 3,056 | Accepted | Accepted | 10.89 | from time import sleep
x = int(eval(input()))
a = int(eval(input()))
b = int(eval(input()))
ans = (x - a) % b
sleep((a%10) * 0.1)
print(ans) | from time import sleep
x = int(eval(input()))
a = int(eval(input()))
b = int(eval(input()))
ans = (x - a) % b
sleep((ans%10) * 0.1)
print(ans) | 11 | 11 | 136 | 138 | from time import sleep
x = int(eval(input()))
a = int(eval(input()))
b = int(eval(input()))
ans = (x - a) % b
sleep((a % 10) * 0.1)
print(ans)
| from time import sleep
x = int(eval(input()))
a = int(eval(input()))
b = int(eval(input()))
ans = (x - a) % b
sleep((ans % 10) * 0.1)
print(ans)
| false | 0 | [
"-sleep((a % 10) * 0.1)",
"+sleep((ans % 10) * 0.1)"
] | false | 0.507575 | 0.486774 | 1.042732 | [
"s253233461",
"s063451933"
] |
u100641536 | p02623 | python | s240966015 | s165507764 | 314 | 241 | 47,716 | 47,828 | Accepted | Accepted | 23.25 | import sys
input = sys.stdin.readline
n,m,k = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
sa = [0] * (n+1)
sb = [0] * (m+1)
for i in range(n):
sa[i+1] = sa[i] + a[i]
for i in range(m):
sb[i+1] = sb[i] + b[i]
rx = 0
rb = m
for ra in range(0,n+1):
while (sb[rb] + sa[ra]) > k and rb>0 :
rb-=1
if (sb[rb] + sa[ra]) <= k:
rx = max(rx,ra+rb)
print(rx)
| import sys
input = sys.stdin.readline
def main():
n,m,k = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
sa = [0] * (n+1)
sb = [0] * (m+1)
for i in range(n):
sa[i+1] = sa[i] + a[i]
for i in range(m):
sb[i+1] = sb[i] + b[i]
rx = 0
rb = m
for ra in range(0,n+1):
while (sb[rb] + sa[ra]) > k and rb>0 :
rb-=1
if (sb[rb] + sa[ra]) <= k:
rx = max(rx,ra+rb)
print(rx)
if __name__ == '__main__':
main() | 20 | 24 | 438 | 526 | import sys
input = sys.stdin.readline
n, m, k = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
sa = [0] * (n + 1)
sb = [0] * (m + 1)
for i in range(n):
sa[i + 1] = sa[i] + a[i]
for i in range(m):
sb[i + 1] = sb[i] + b[i]
rx = 0
rb = m
for ra in range(0, n + 1):
while (sb[rb] + sa[ra]) > k and rb > 0:
rb -= 1
if (sb[rb] + sa[ra]) <= k:
rx = max(rx, ra + rb)
print(rx)
| import sys
input = sys.stdin.readline
def main():
n, m, k = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
sa = [0] * (n + 1)
sb = [0] * (m + 1)
for i in range(n):
sa[i + 1] = sa[i] + a[i]
for i in range(m):
sb[i + 1] = sb[i] + b[i]
rx = 0
rb = m
for ra in range(0, n + 1):
while (sb[rb] + sa[ra]) > k and rb > 0:
rb -= 1
if (sb[rb] + sa[ra]) <= k:
rx = max(rx, ra + rb)
print(rx)
if __name__ == "__main__":
main()
| false | 16.666667 | [
"-n, m, k = list(map(int, input().split()))",
"-a = list(map(int, input().split()))",
"-b = list(map(int, input().split()))",
"-sa = [0] * (n + 1)",
"-sb = [0] * (m + 1)",
"-for i in range(n):",
"- sa[i + 1] = sa[i] + a[i]",
"-for i in range(m):",
"- sb[i + 1] = sb[i] + b[i]",
"-rx = 0",
"-rb = m",
"-for ra in range(0, n + 1):",
"- while (sb[rb] + sa[ra]) > k and rb > 0:",
"- rb -= 1",
"- if (sb[rb] + sa[ra]) <= k:",
"- rx = max(rx, ra + rb)",
"-print(rx)",
"+",
"+",
"+def main():",
"+ n, m, k = list(map(int, input().split()))",
"+ a = list(map(int, input().split()))",
"+ b = list(map(int, input().split()))",
"+ sa = [0] * (n + 1)",
"+ sb = [0] * (m + 1)",
"+ for i in range(n):",
"+ sa[i + 1] = sa[i] + a[i]",
"+ for i in range(m):",
"+ sb[i + 1] = sb[i] + b[i]",
"+ rx = 0",
"+ rb = m",
"+ for ra in range(0, n + 1):",
"+ while (sb[rb] + sa[ra]) > k and rb > 0:",
"+ rb -= 1",
"+ if (sb[rb] + sa[ra]) <= k:",
"+ rx = max(rx, ra + rb)",
"+ print(rx)",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false | 0.035078 | 0.035326 | 0.992982 | [
"s240966015",
"s165507764"
] |
u515740713 | p02629 | python | s218596714 | s601393858 | 34 | 28 | 9,264 | 9,144 | Accepted | Accepted | 17.65 | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N = int(readline())
A = []
while(N>26):
s = N % 26
if s == 0:
A.append(26)
N = (N-26) // 26
else:
A.append(s)
N = (N-s) // 26
A.append(N)
A = A[::-1]
ans = ''
d = ['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z']
for i in A:
ans += d[i-1]
print(ans) | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N = int(readline())
res = ''
while(N):
N -= 1
res += chr(ord('a') + N % 26)
N //= 26
print((res[::-1])) | 21 | 11 | 480 | 240 | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N = int(readline())
A = []
while N > 26:
s = N % 26
if s == 0:
A.append(26)
N = (N - 26) // 26
else:
A.append(s)
N = (N - s) // 26
A.append(N)
A = A[::-1]
ans = ""
d = [
"a",
"b",
"c",
"d",
"e",
"f",
"g",
"h",
"i",
"j",
"k",
"l",
"m",
"n",
"o",
"p",
"q",
"r",
"s",
"t",
"u",
"v",
"w",
"x",
"y",
"z",
]
for i in A:
ans += d[i - 1]
print(ans)
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N = int(readline())
res = ""
while N:
N -= 1
res += chr(ord("a") + N % 26)
N //= 26
print((res[::-1]))
| false | 47.619048 | [
"-A = []",
"-while N > 26:",
"- s = N % 26",
"- if s == 0:",
"- A.append(26)",
"- N = (N - 26) // 26",
"- else:",
"- A.append(s)",
"- N = (N - s) // 26",
"-A.append(N)",
"-A = A[::-1]",
"-ans = \"\"",
"-d = [",
"- \"a\",",
"- \"b\",",
"- \"c\",",
"- \"d\",",
"- \"e\",",
"- \"f\",",
"- \"g\",",
"- \"h\",",
"- \"i\",",
"- \"j\",",
"- \"k\",",
"- \"l\",",
"- \"m\",",
"- \"n\",",
"- \"o\",",
"- \"p\",",
"- \"q\",",
"- \"r\",",
"- \"s\",",
"- \"t\",",
"- \"u\",",
"- \"v\",",
"- \"w\",",
"- \"x\",",
"- \"y\",",
"- \"z\",",
"-]",
"-for i in A:",
"- ans += d[i - 1]",
"-print(ans)",
"+res = \"\"",
"+while N:",
"+ N -= 1",
"+ res += chr(ord(\"a\") + N % 26)",
"+ N //= 26",
"+print((res[::-1]))"
] | false | 0.040211 | 0.034095 | 1.179365 | [
"s218596714",
"s601393858"
] |
u777241657 | p02779 | python | s834909107 | s705911116 | 349 | 185 | 20,796 | 26,676 | Accepted | Accepted | 46.99 | length=eval(input())
#len-1
Narray=sorted(input().split())
n=0
while n<int(length)-1:
if Narray[n] == Narray[n+1]:
print("NO")
break
elif n==int(length)-2:
print("YES")
break
else:
n+=1
| s=eval(input())
array=[]
array+=(int(x) for x in input().split())
array.sort()
def judge(array,s):
for i in range(int(s)-1):
if array[i] == array[i+1]:
return "NO"
return "YES"
print((judge(array,s)))
| 14 | 13 | 211 | 225 | length = eval(input())
# len-1
Narray = sorted(input().split())
n = 0
while n < int(length) - 1:
if Narray[n] == Narray[n + 1]:
print("NO")
break
elif n == int(length) - 2:
print("YES")
break
else:
n += 1
| s = eval(input())
array = []
array += (int(x) for x in input().split())
array.sort()
def judge(array, s):
for i in range(int(s) - 1):
if array[i] == array[i + 1]:
return "NO"
return "YES"
print((judge(array, s)))
| false | 7.142857 | [
"-length = eval(input())",
"-# len-1",
"-Narray = sorted(input().split())",
"-n = 0",
"-while n < int(length) - 1:",
"- if Narray[n] == Narray[n + 1]:",
"- print(\"NO\")",
"- break",
"- elif n == int(length) - 2:",
"- print(\"YES\")",
"- break",
"- else:",
"- n += 1",
"+s = eval(input())",
"+array = []",
"+array += (int(x) for x in input().split())",
"+array.sort()",
"+",
"+",
"+def judge(array, s):",
"+ for i in range(int(s) - 1):",
"+ if array[i] == array[i + 1]:",
"+ return \"NO\"",
"+ return \"YES\"",
"+",
"+",
"+print((judge(array, s)))"
] | false | 0.036261 | 0.035812 | 1.012521 | [
"s834909107",
"s705911116"
] |
u766163292 | p02376 | python | s992468613 | s332738848 | 2,480 | 850 | 8,740 | 8,800 | Accepted | Accepted | 65.73 | #!/usr/bin/env python3
# Based on ...
# https://en.wikipedia.org/wiki/Ford???Fulkerson_algorithm
# http://algoogle.hadrori.jp/algorithm/ford-fulkerson.html
import collections
import sys
REC_LIMIT = 10000
INF = 10 ** 8
class Edge(object):
def __init__(self, source, sink, capacity):
self.source = source
self.sink = sink
self.capacity = capacity
self.rev_edge = None
def __str__(self):
return "Edge {} -> {} : {}".format(self.source,
self.sink, self.capacity)
class FlowNetwork(object):
def __init__(self):
self.adj_edges = collections.defaultdict(list)
self.flow = dict()
self.used_edge = None
def get_edges_from(self, vertex):
return self.adj_edges[vertex]
def add_edge(self, source, sink, capacity):
assert source != sink
f_edge = Edge(source, sink, capacity)
b_edge = Edge(sink, source, 0)
f_edge.rev_edge = b_edge
b_edge.rev_edge = f_edge
self.adj_edges[source].append(f_edge)
self.adj_edges[sink].append(b_edge)
self.flow[f_edge] = 0
self.flow[b_edge] = 0
def dfs(self, source, sink, flow):
if source == sink:
return flow
self.used_edge[source] = True
for edge in self.get_edges_from(source):
residual = edge.capacity - self.flow[edge]
if self.used_edge[edge.sink] or residual <= 0:
continue
d = self.dfs(edge.sink, sink, min(flow, residual))
if d > 0:
self.flow[edge] += d
self.flow[edge.rev_edge] -= d
return d
return 0
def ford_fulkerson(self, source, sink):
max_flow = 0
while True:
self.used_edge = collections.defaultdict(bool)
df = self.dfs(source, sink, INF)
if df == 0:
return max_flow
else:
max_flow += df
def main():
sys.setrecursionlimit(REC_LIMIT)
v, e = list(map(int, input().split()))
network = FlowNetwork()
for _ in range(e):
network.add_edge(*list(map(int, input().split())))
mf = network.ford_fulkerson(0, v - 1)
print(mf)
if __name__ == '__main__':
main() | #!/usr/bin/env python3
# Based on
# https://en.wikipedia.org/wiki/Ford???Fulkerson_algorithm
# http://algoogle.hadrori.jp/algorithm/ford-fulkerson.html
import array
import collections
import sys
REC_LIMIT = 10000
INF = 10 ** 8
Edge = collections.namedtuple("Edge", "source sink capacity")
class FlowNetwork(object):
def __init__(self, num_vertices):
self.adj_edges = [set() for _ in range(num_vertices)]
self.flow = None
self.rev_edge = dict()
self.used = None
def get_edges_from(self, vertex):
return self.adj_edges[vertex]
def add_edge(self, source, sink, capacity):
assert source != sink
forward_edge = Edge(source, sink, capacity)
backward_edge = Edge(sink, source, 0)
self.rev_edge[forward_edge] = backward_edge
self.rev_edge[backward_edge] = forward_edge
self.adj_edges[source].add(forward_edge)
self.adj_edges[sink].add(backward_edge)
def dfs(self, source, sink, flow):
if source == sink:
return flow
self.used[source] = True
for edge in self.get_edges_from(source):
rest = edge.capacity - self.flow[edge]
if self.used[edge.sink] or rest <= 0:
continue
d = self.dfs(edge.sink, sink, min(flow, rest))
if d > 0:
self.flow[edge] += d
self.flow[self.rev_edge[edge]] -= d
return d
return 0
def ford_fulkerson(self, source, sink):
self.flow = collections.defaultdict(int)
max_flow = 0
while True:
self.used = collections.defaultdict(bool)
df = self.dfs(source, sink, INF)
if df == 0:
return max_flow
else:
max_flow += df
def main():
sys.setrecursionlimit(REC_LIMIT)
v, e = list(map(int, input().split()))
network = FlowNetwork(v)
for _ in range(e):
network.add_edge(*list(map(int, input().split())))
mf = network.ford_fulkerson(0, v - 1)
print(mf)
if __name__ == '__main__':
main() | 85 | 76 | 2,373 | 2,173 | #!/usr/bin/env python3
# Based on ...
# https://en.wikipedia.org/wiki/Ford???Fulkerson_algorithm
# http://algoogle.hadrori.jp/algorithm/ford-fulkerson.html
import collections
import sys
REC_LIMIT = 10000
INF = 10**8
class Edge(object):
def __init__(self, source, sink, capacity):
self.source = source
self.sink = sink
self.capacity = capacity
self.rev_edge = None
def __str__(self):
return "Edge {} -> {} : {}".format(self.source, self.sink, self.capacity)
class FlowNetwork(object):
def __init__(self):
self.adj_edges = collections.defaultdict(list)
self.flow = dict()
self.used_edge = None
def get_edges_from(self, vertex):
return self.adj_edges[vertex]
def add_edge(self, source, sink, capacity):
assert source != sink
f_edge = Edge(source, sink, capacity)
b_edge = Edge(sink, source, 0)
f_edge.rev_edge = b_edge
b_edge.rev_edge = f_edge
self.adj_edges[source].append(f_edge)
self.adj_edges[sink].append(b_edge)
self.flow[f_edge] = 0
self.flow[b_edge] = 0
def dfs(self, source, sink, flow):
if source == sink:
return flow
self.used_edge[source] = True
for edge in self.get_edges_from(source):
residual = edge.capacity - self.flow[edge]
if self.used_edge[edge.sink] or residual <= 0:
continue
d = self.dfs(edge.sink, sink, min(flow, residual))
if d > 0:
self.flow[edge] += d
self.flow[edge.rev_edge] -= d
return d
return 0
def ford_fulkerson(self, source, sink):
max_flow = 0
while True:
self.used_edge = collections.defaultdict(bool)
df = self.dfs(source, sink, INF)
if df == 0:
return max_flow
else:
max_flow += df
def main():
sys.setrecursionlimit(REC_LIMIT)
v, e = list(map(int, input().split()))
network = FlowNetwork()
for _ in range(e):
network.add_edge(*list(map(int, input().split())))
mf = network.ford_fulkerson(0, v - 1)
print(mf)
if __name__ == "__main__":
main()
| #!/usr/bin/env python3
# Based on
# https://en.wikipedia.org/wiki/Ford???Fulkerson_algorithm
# http://algoogle.hadrori.jp/algorithm/ford-fulkerson.html
import array
import collections
import sys
REC_LIMIT = 10000
INF = 10**8
Edge = collections.namedtuple("Edge", "source sink capacity")
class FlowNetwork(object):
def __init__(self, num_vertices):
self.adj_edges = [set() for _ in range(num_vertices)]
self.flow = None
self.rev_edge = dict()
self.used = None
def get_edges_from(self, vertex):
return self.adj_edges[vertex]
def add_edge(self, source, sink, capacity):
assert source != sink
forward_edge = Edge(source, sink, capacity)
backward_edge = Edge(sink, source, 0)
self.rev_edge[forward_edge] = backward_edge
self.rev_edge[backward_edge] = forward_edge
self.adj_edges[source].add(forward_edge)
self.adj_edges[sink].add(backward_edge)
def dfs(self, source, sink, flow):
if source == sink:
return flow
self.used[source] = True
for edge in self.get_edges_from(source):
rest = edge.capacity - self.flow[edge]
if self.used[edge.sink] or rest <= 0:
continue
d = self.dfs(edge.sink, sink, min(flow, rest))
if d > 0:
self.flow[edge] += d
self.flow[self.rev_edge[edge]] -= d
return d
return 0
def ford_fulkerson(self, source, sink):
self.flow = collections.defaultdict(int)
max_flow = 0
while True:
self.used = collections.defaultdict(bool)
df = self.dfs(source, sink, INF)
if df == 0:
return max_flow
else:
max_flow += df
def main():
sys.setrecursionlimit(REC_LIMIT)
v, e = list(map(int, input().split()))
network = FlowNetwork(v)
for _ in range(e):
network.add_edge(*list(map(int, input().split())))
mf = network.ford_fulkerson(0, v - 1)
print(mf)
if __name__ == "__main__":
main()
| false | 10.588235 | [
"-# Based on ...",
"+# Based on",
"+import array",
"-",
"-",
"-class Edge(object):",
"- def __init__(self, source, sink, capacity):",
"- self.source = source",
"- self.sink = sink",
"- self.capacity = capacity",
"- self.rev_edge = None",
"-",
"- def __str__(self):",
"- return \"Edge {} -> {} : {}\".format(self.source, self.sink, self.capacity)",
"+Edge = collections.namedtuple(\"Edge\", \"source sink capacity\")",
"- def __init__(self):",
"- self.adj_edges = collections.defaultdict(list)",
"- self.flow = dict()",
"- self.used_edge = None",
"+ def __init__(self, num_vertices):",
"+ self.adj_edges = [set() for _ in range(num_vertices)]",
"+ self.flow = None",
"+ self.rev_edge = dict()",
"+ self.used = None",
"- f_edge = Edge(source, sink, capacity)",
"- b_edge = Edge(sink, source, 0)",
"- f_edge.rev_edge = b_edge",
"- b_edge.rev_edge = f_edge",
"- self.adj_edges[source].append(f_edge)",
"- self.adj_edges[sink].append(b_edge)",
"- self.flow[f_edge] = 0",
"- self.flow[b_edge] = 0",
"+ forward_edge = Edge(source, sink, capacity)",
"+ backward_edge = Edge(sink, source, 0)",
"+ self.rev_edge[forward_edge] = backward_edge",
"+ self.rev_edge[backward_edge] = forward_edge",
"+ self.adj_edges[source].add(forward_edge)",
"+ self.adj_edges[sink].add(backward_edge)",
"- self.used_edge[source] = True",
"+ self.used[source] = True",
"- residual = edge.capacity - self.flow[edge]",
"- if self.used_edge[edge.sink] or residual <= 0:",
"+ rest = edge.capacity - self.flow[edge]",
"+ if self.used[edge.sink] or rest <= 0:",
"- d = self.dfs(edge.sink, sink, min(flow, residual))",
"+ d = self.dfs(edge.sink, sink, min(flow, rest))",
"- self.flow[edge.rev_edge] -= d",
"+ self.flow[self.rev_edge[edge]] -= d",
"+ self.flow = collections.defaultdict(int)",
"- self.used_edge = collections.defaultdict(bool)",
"+ self.used = collections.defaultdict(bool)",
"- network = FlowNetwork()",
"+ network = FlowNetwork(v)"
] | false | 0.036493 | 0.036192 | 1.008333 | [
"s992468613",
"s332738848"
] |
u226108478 | p03074 | python | s639679856 | s136480382 | 98 | 76 | 4,776 | 9,380 | Accepted | Accepted | 22.45 | # -*- coding: utf-8 -*-
def main():
n, k = list(map(int, input().split()))
s = list(eval(input()))
nums = list()
now = 1
count = 0
# See:
# https://www.youtube.com/watch?v=FRzpDCx17vw
# 1と0が連続していくつ続いているかを数える
# 一つの配列で管理
for si in s:
if si == str(now):
count += 1
else:
nums.append(count)
now = 1 - now # 0と1を切り替える
count = 1
# 端部の処理
if count != 0:
nums.append(count)
# 1-0-1-0-1の形になっている必要がある
if len(nums) % 2 == 0:
nums.append(0)
add = 2 * k + 1
# 1. left，rightをfor文の前に
left = 0
right = 0 # [left, right)
tmp = 0
ans = 0
# 偶数番目に着目
for i in range(0, len(nums), 2):
# 2. 次のleft, rightを決める
next_left = i
next_right = min(i + add, len(nums))
# 3.
# 左端を移動
while next_left > left:
tmp -= nums[left]
left += 1
# 右端を移動
while next_right > right:
tmp += nums[right]
right += 1
ans = max(ans, tmp)
print(ans)
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
def main():
from itertools import accumulate
n, k = list(map(int, input().split()))
s = list(eval(input()))
nums = list()
now = 1
count = 0
# See:
# https://www.youtube.com/watch?v=FRzpDCx17vw
# 1と0が連続していくつ続いているかを数える
# 一つの配列で管理
for si in s:
if si == str(now):
count += 1
else:
nums.append(count)
now = 1 - now # 0と1を切り替える
count = 1
# 端部の処理
if count != 0:
nums.append(count)
# 1-0-1-0-1の形になっている必要がある
if len(nums) % 2 == 0:
nums.append(0)
add = 2 * k + 1
# 累積和
summed = list(accumulate([0] + nums))
tmp = 0
ans = 0
# 偶数番目に着目
for i in range(0, len(nums), 2):
left = i
right = min(i + add, len(nums))
tmp = summed[right] - summed[left]
ans = max(ans, tmp)
print(ans)
if __name__ == '__main__':
main()
| 63 | 54 | 1,193 | 986 | # -*- coding: utf-8 -*-
def main():
n, k = list(map(int, input().split()))
s = list(eval(input()))
nums = list()
now = 1
count = 0
# See:
# https://www.youtube.com/watch?v=FRzpDCx17vw
# 1と0が連続していくつ続いているかを数える
# 一つの配列で管理
for si in s:
if si == str(now):
count += 1
else:
nums.append(count)
now = 1 - now # 0と1を切り替える
count = 1
# 端部の処理
if count != 0:
nums.append(count)
# 1-0-1-0-1の形になっている必要がある
if len(nums) % 2 == 0:
nums.append(0)
add = 2 * k + 1
# 1. left，rightをfor文の前に
left = 0
right = 0 # [left, right)
tmp = 0
ans = 0
# 偶数番目に着目
for i in range(0, len(nums), 2):
# 2. 次のleft, rightを決める
next_left = i
next_right = min(i + add, len(nums))
# 3.
# 左端を移動
while next_left > left:
tmp -= nums[left]
left += 1
# 右端を移動
while next_right > right:
tmp += nums[right]
right += 1
ans = max(ans, tmp)
print(ans)
if __name__ == "__main__":
main()
| # -*- coding: utf-8 -*-
def main():
from itertools import accumulate
n, k = list(map(int, input().split()))
s = list(eval(input()))
nums = list()
now = 1
count = 0
# See:
# https://www.youtube.com/watch?v=FRzpDCx17vw
# 1と0が連続していくつ続いているかを数える
# 一つの配列で管理
for si in s:
if si == str(now):
count += 1
else:
nums.append(count)
now = 1 - now # 0と1を切り替える
count = 1
# 端部の処理
if count != 0:
nums.append(count)
# 1-0-1-0-1の形になっている必要がある
if len(nums) % 2 == 0:
nums.append(0)
add = 2 * k + 1
# 累積和
summed = list(accumulate([0] + nums))
tmp = 0
ans = 0
# 偶数番目に着目
for i in range(0, len(nums), 2):
left = i
right = min(i + add, len(nums))
tmp = summed[right] - summed[left]
ans = max(ans, tmp)
print(ans)
if __name__ == "__main__":
main()
| false | 14.285714 | [
"+ from itertools import accumulate",
"+",
"- # 1. left，rightをfor文の前に",
"- left = 0",
"- right = 0 # [left, right)",
"+ # 累積和",
"+ summed = list(accumulate([0] + nums))",
"- # 2. 次のleft, rightを決める",
"- next_left = i",
"- next_right = min(i + add, len(nums))",
"- # 3.",
"- # 左端を移動",
"- while next_left > left:",
"- tmp -= nums[left]",
"- left += 1",
"- # 右端を移動",
"- while next_right > right:",
"- tmp += nums[right]",
"- right += 1",
"+ left = i",
"+ right = min(i + add, len(nums))",
"+ tmp = summed[right] - summed[left]"
] | false | 0.039576 | 0.046685 | 0.84771 | [
"s639679856",
"s136480382"
] |
u368780724 | p03765 | python | s999876039 | s570056569 | 1,113 | 389 | 55,436 | 59,348 | Accepted | Accepted | 65.05 | def inpl(): return [int(i) for i in input().split()]
S = eval(input())
T = eval(input())
typeS = [0 for _ in range(1+len(S))]
typeT = [0 for _ in range(1+len(T))]
typeS[0] = typeT[0] = 0
for i in range(len(S)):
ctr = 2
if S[i] == 'A':
ctr = 1
typeS[i+1] = (typeS[i] + ctr)%3
for i in range(len(T)):
ctr = 2
if T[i] == 'A':
ctr = 1
typeT[i+1] = (typeT[i] + ctr)%3
Q = int(eval(input()))
for _ in range(Q):
a, b, c, d = inpl()
if (typeS[b] - typeS[a-1])%3 == (typeT[d] -typeT[c-1])%3:
print('YES')
else:
print('NO') | import sys
from itertools import accumulate
readline = sys.stdin.readline
S = [1 if s == 'A' else 2 for s in readline().strip()]
T = [1 if s == 'A' else 2 for s in readline().strip()]
AS = [0] + list(accumulate(S))
AT = [0] + list(accumulate(T))
Q = int(readline())
Ans = [None]*Q
for qu in range(Q):
a, b, c, d = list(map(int, readline().split()))
if (AS[b]-AS[a-1])%3 != (AT[d]-AT[c-1])%3:
Ans[qu] = 'NO'
else:
Ans[qu] = 'YES'
print(('\n'.join(map(str, Ans)))) | 24 | 19 | 588 | 508 | def inpl():
return [int(i) for i in input().split()]
S = eval(input())
T = eval(input())
typeS = [0 for _ in range(1 + len(S))]
typeT = [0 for _ in range(1 + len(T))]
typeS[0] = typeT[0] = 0
for i in range(len(S)):
ctr = 2
if S[i] == "A":
ctr = 1
typeS[i + 1] = (typeS[i] + ctr) % 3
for i in range(len(T)):
ctr = 2
if T[i] == "A":
ctr = 1
typeT[i + 1] = (typeT[i] + ctr) % 3
Q = int(eval(input()))
for _ in range(Q):
a, b, c, d = inpl()
if (typeS[b] - typeS[a - 1]) % 3 == (typeT[d] - typeT[c - 1]) % 3:
print("YES")
else:
print("NO")
| import sys
from itertools import accumulate
readline = sys.stdin.readline
S = [1 if s == "A" else 2 for s in readline().strip()]
T = [1 if s == "A" else 2 for s in readline().strip()]
AS = [0] + list(accumulate(S))
AT = [0] + list(accumulate(T))
Q = int(readline())
Ans = [None] * Q
for qu in range(Q):
a, b, c, d = list(map(int, readline().split()))
if (AS[b] - AS[a - 1]) % 3 != (AT[d] - AT[c - 1]) % 3:
Ans[qu] = "NO"
else:
Ans[qu] = "YES"
print(("\n".join(map(str, Ans))))
| false | 20.833333 | [
"-def inpl():",
"- return [int(i) for i in input().split()]",
"+import sys",
"+from itertools import accumulate",
"-",
"-S = eval(input())",
"-T = eval(input())",
"-typeS = [0 for _ in range(1 + len(S))]",
"-typeT = [0 for _ in range(1 + len(T))]",
"-typeS[0] = typeT[0] = 0",
"-for i in range(len(S)):",
"- ctr = 2",
"- if S[i] == \"A\":",
"- ctr = 1",
"- typeS[i + 1] = (typeS[i] + ctr) % 3",
"-for i in range(len(T)):",
"- ctr = 2",
"- if T[i] == \"A\":",
"- ctr = 1",
"- typeT[i + 1] = (typeT[i] + ctr) % 3",
"-Q = int(eval(input()))",
"-for _ in range(Q):",
"- a, b, c, d = inpl()",
"- if (typeS[b] - typeS[a - 1]) % 3 == (typeT[d] - typeT[c - 1]) % 3:",
"- print(\"YES\")",
"+readline = sys.stdin.readline",
"+S = [1 if s == \"A\" else 2 for s in readline().strip()]",
"+T = [1 if s == \"A\" else 2 for s in readline().strip()]",
"+AS = [0] + list(accumulate(S))",
"+AT = [0] + list(accumulate(T))",
"+Q = int(readline())",
"+Ans = [None] * Q",
"+for qu in range(Q):",
"+ a, b, c, d = list(map(int, readline().split()))",
"+ if (AS[b] - AS[a - 1]) % 3 != (AT[d] - AT[c - 1]) % 3:",
"+ Ans[qu] = \"NO\"",
"- print(\"NO\")",
"+ Ans[qu] = \"YES\"",
"+print((\"\\n\".join(map(str, Ans))))"
] | false | 0.038756 | 0.057939 | 0.668917 | [
"s999876039",
"s570056569"
] |
u054514819 | p02549 | python | s170952210 | s629014650 | 356 | 118 | 72,400 | 77,988 | Accepted | Accepted | 66.85 | import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return list(map(int, input().split()))
sys.setrecursionlimit(10**9)
N, K = mapint()
mod = 998244353
dp = [0]*(N+1)
dp[1] = 1
Ks = [list(mapint()) for _ in range(K)]
Ks.sort()
class Bit:
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def sums(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.tree[i] += x
i += i & -i
bit = Bit(N)
bit.add(1, 1)
for i in range(2, N+1):
for l, r in Ks:
if i-l<0:
break
dp[i] += bit.sums(i-l) - bit.sums(max(0, i-r-1))
dp[i] %= mod
bit.add(i, dp[i])
print((dp[-1])) | import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return list(map(int, input().split()))
sys.setrecursionlimit(10**9)
N, K = mapint()
dp = [0]*(N*3+1)
dp[1] = 1
dp[2] = -1
mod = 998244353
LR = [list(mapint()) for _ in range(K)]
for i in range(1, N+1):
dp[i] = (dp[i]+dp[i-1])%mod
for l, r in LR:
dp[i+l] = (dp[i+l]+dp[i])%mod
dp[i+r+1] = (dp[i+r+1]-dp[i])%mod
print((dp[N])) | 42 | 18 | 846 | 433 | import sys
def input():
return sys.stdin.readline().strip()
def mapint():
return list(map(int, input().split()))
sys.setrecursionlimit(10**9)
N, K = mapint()
mod = 998244353
dp = [0] * (N + 1)
dp[1] = 1
Ks = [list(mapint()) for _ in range(K)]
Ks.sort()
class Bit:
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def sums(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.tree[i] += x
i += i & -i
bit = Bit(N)
bit.add(1, 1)
for i in range(2, N + 1):
for l, r in Ks:
if i - l < 0:
break
dp[i] += bit.sums(i - l) - bit.sums(max(0, i - r - 1))
dp[i] %= mod
bit.add(i, dp[i])
print((dp[-1]))
| import sys
def input():
return sys.stdin.readline().strip()
def mapint():
return list(map(int, input().split()))
sys.setrecursionlimit(10**9)
N, K = mapint()
dp = [0] * (N * 3 + 1)
dp[1] = 1
dp[2] = -1
mod = 998244353
LR = [list(mapint()) for _ in range(K)]
for i in range(1, N + 1):
dp[i] = (dp[i] + dp[i - 1]) % mod
for l, r in LR:
dp[i + l] = (dp[i + l] + dp[i]) % mod
dp[i + r + 1] = (dp[i + r + 1] - dp[i]) % mod
print((dp[N]))
| false | 57.142857 | [
"+dp = [0] * (N * 3 + 1)",
"+dp[1] = 1",
"+dp[2] = -1",
"-dp = [0] * (N + 1)",
"-dp[1] = 1",
"-Ks = [list(mapint()) for _ in range(K)]",
"-Ks.sort()",
"-",
"-",
"-class Bit:",
"- def __init__(self, n):",
"- self.size = n",
"- self.tree = [0] * (n + 1)",
"-",
"- def sums(self, i):",
"- s = 0",
"- while i > 0:",
"- s += self.tree[i]",
"- i -= i & -i",
"- return s",
"-",
"- def add(self, i, x):",
"- while i <= self.size:",
"- self.tree[i] += x",
"- i += i & -i",
"-",
"-",
"-bit = Bit(N)",
"-bit.add(1, 1)",
"-for i in range(2, N + 1):",
"- for l, r in Ks:",
"- if i - l < 0:",
"- break",
"- dp[i] += bit.sums(i - l) - bit.sums(max(0, i - r - 1))",
"- dp[i] %= mod",
"- bit.add(i, dp[i])",
"-print((dp[-1]))",
"+LR = [list(mapint()) for _ in range(K)]",
"+for i in range(1, N + 1):",
"+ dp[i] = (dp[i] + dp[i - 1]) % mod",
"+ for l, r in LR:",
"+ dp[i + l] = (dp[i + l] + dp[i]) % mod",
"+ dp[i + r + 1] = (dp[i + r + 1] - dp[i]) % mod",
"+print((dp[N]))"
] | false | 0.074171 | 0.03667 | 2.022655 | [
"s170952210",
"s629014650"
] |
u506858457 | p02936 | python | s589618321 | s288990027 | 1,831 | 1,096 | 268,572 | 283,020 | Accepted | Accepted | 40.14 | #@hoshikawa1309
# dfsを用いて累積和を計算する
import sys
sys.setrecursionlimit(10 ** 6)
def input():#入力方法にも注意
return sys.stdin.readline()[:-1]
N , Q = list(map(int,input().split()))
graph = [[] for _ in range(N)]
point = [0] * N
for _ in range(N - 1):
a , b = list(map(int,input().split()))
graph[a - 1].append(b - 1)
graph[b - 1].append(a - 1)
for _ in range(Q):
a , b = list(map(int,input().split()))
a = a - 1
point[a] += b
# 初期状態だと前の値がないためデフォルト引数に-1を代入
def dfs(now , prev = -1):
for next in graph[now]:#いま見ているノードから行けるノードをチェック
# 次のノードが前に参照した値の時はcontinue、逆走防止
if next == prev:
continue
# 現在の値を次のポイントに加算することで累積和をとる
point[next] += point[now]#実質的な処理は、これだけ
# 次のノードと現在のノードを引数にdfsを継続する
dfs(next , now)
dfs(0)
print((*point)) | import sys
sys.setrecursionlimit(10 ** 6)
import sys
def input():
return sys.stdin.readline()[:-1]
N , Q = list(map(int,input().split()))
graph = [[] for _ in range(N)]
point = [0] * N
for _ in range(N - 1):
a , b = list(map(int,input().split()))
graph[a - 1].append(b - 1)
graph[b - 1].append(a - 1)
#print(graph)
for _ in range(Q):
a , b = list(map(int,input().split()))
a = a - 1
point[a] += b
# dfsを用いて累積和を計算する
# 初期状態だと前の値がないためデフォルト引数に-1を代入
def dfs(now , prev = -1):
for next in graph[now]:
# 次のノードが前に参照した値の時はcontinue
if next == prev:
continue
# 現在の値を次のポイントに加算することで累積和をとる
point[next] += point[now]
# 次のノードと現在のノードを引数にdfsを継続する
dfs(next , now)
dfs(0)
print((*point)) | 29 | 31 | 808 | 770 | # @hoshikawa1309
# dfsを用いて累積和を計算する
import sys
sys.setrecursionlimit(10**6)
def input(): # 入力方法にも注意
return sys.stdin.readline()[:-1]
N, Q = list(map(int, input().split()))
graph = [[] for _ in range(N)]
point = [0] * N
for _ in range(N - 1):
a, b = list(map(int, input().split()))
graph[a - 1].append(b - 1)
graph[b - 1].append(a - 1)
for _ in range(Q):
a, b = list(map(int, input().split()))
a = a - 1
point[a] += b
# 初期状態だと前の値がないためデフォルト引数に-1を代入
def dfs(now, prev=-1):
for next in graph[now]: # いま見ているノードから行けるノードをチェック
# 次のノードが前に参照した値の時はcontinue、逆走防止
if next == prev:
continue
# 現在の値を次のポイントに加算することで累積和をとる
point[next] += point[now] # 実質的な処理は、これだけ
# 次のノードと現在のノードを引数にdfsを継続する
dfs(next, now)
dfs(0)
print((*point))
| import sys
sys.setrecursionlimit(10**6)
import sys
def input():
return sys.stdin.readline()[:-1]
N, Q = list(map(int, input().split()))
graph = [[] for _ in range(N)]
point = [0] * N
for _ in range(N - 1):
a, b = list(map(int, input().split()))
graph[a - 1].append(b - 1)
graph[b - 1].append(a - 1)
# print(graph)
for _ in range(Q):
a, b = list(map(int, input().split()))
a = a - 1
point[a] += b
# dfsを用いて累積和を計算する
# 初期状態だと前の値がないためデフォルト引数に-1を代入
def dfs(now, prev=-1):
for next in graph[now]:
# 次のノードが前に参照した値の時はcontinue
if next == prev:
continue
# 現在の値を次のポイントに加算することで累積和をとる
point[next] += point[now]
# 次のノードと現在のノードを引数にdfsを継続する
dfs(next, now)
dfs(0)
print((*point))
| false | 6.451613 | [
"-# @hoshikawa1309",
"-# dfsを用いて累積和を計算する",
"+import sys",
"-def input(): # 入力方法にも注意",
"+def input():",
"+# print(graph)",
"+# dfsを用いて累積和を計算する",
"- for next in graph[now]: # いま見ているノードから行けるノードをチェック",
"- # 次のノードが前に参照した値の時はcontinue、逆走防止",
"+ for next in graph[now]:",
"+ # 次のノードが前に参照した値の時はcontinue",
"- point[next] += point[now] # 実質的な処理は、これだけ",
"+ point[next] += point[now]"
] | false | 0.035101 | 0.036346 | 0.965747 | [
"s589618321",
"s288990027"
] |
u022407960 | p02366 | python | s109837236 | s785890302 | 200 | 160 | 23,708 | 23,784 | Accepted | Accepted | 20 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
5 4
0 1
1 2
2 3
3 4
output:
1
2
3
"""
import sys
sys.setrecursionlimit(int(1e5))
def dfs_Tarjan(current):
global timer
children = 0
visited[current] = True
disc[current] = low[current] = timer
timer += 1
for adj in adj_table[current]:
if not visited[adj]:
parent[adj] = current
children += 1
dfs_Tarjan(adj)
low[current] = min(low[current], low[adj])
if parent[current] == -1 and children > 1:
art_set.add(current)
elif parent[current] != -1 and low[adj] >= disc[current]:
art_set.add(current)
elif adj != parent[current]:
low[current] = min(low[current], disc[adj])
return None
def dfs_init():
for v in range(v_num):
if not visited[v]:
dfs_Tarjan(v)
return None
if __name__ == '__main__':
_input = sys.stdin.readlines()
v_num, e_num = map(int, _input[0].split())
edges = map(lambda x: x.split(), _input[1:])
adj_table = tuple([] for _ in range(v_num))
for edge in edges:
source, target = map(int, edge)
adj_table[source].append(target)
adj_table[target].append(source)
timer = 0
art_set = set()
parent = [-1] * v_num
visited = [False] * v_num
disc, low = ([float('inf')] * v_num for _ in range(2))
dfs_init()
if art_set:
print(*sorted(art_set), sep='\n')
| #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
5 4
0 1
1 2
2 3
3 4
output:
1
2
3
"""
import sys
sys.setrecursionlimit(int(1e5))
def dfs_Tarjan(current, visited, disc, low, parent):
global timer
children = 0
visited[current] = True
disc[current] = low[current] = timer
timer += 1
for adj in adj_table[current]:
if not visited[adj]:
parent[adj] = current
children += 1
dfs_Tarjan(adj, visited, disc, low, parent)
low[current] = min(low[current], low[adj])
if parent[current] == -1 and children > 1:
art_set.add(current)
elif parent[current] != -1 and low[adj] >= disc[current]:
art_set.add(current)
elif adj != parent[current]:
low[current] = min(low[current], disc[adj])
return None
def dfs_init():
parent = [-1] * v_num
visited = [False] * v_num
disc, low = ([float('inf')] * v_num for _ in range(2))
for v in range(v_num):
if not visited[v]:
dfs_Tarjan(v, visited, disc, low, parent)
return None
if __name__ == '__main__':
_input = sys.stdin.readlines()
v_num, e_num = map(int, _input[0].split())
edges = map(lambda x: x.split(), _input[1:])
adj_table = tuple([] for _ in range(v_num))
for edge in edges:
source, target = map(int, edge)
adj_table[source].append(target)
adj_table[target].append(source)
timer = 0
art_set = set()
# generate articulation points set
dfs_init()
if art_set:
print(*sorted(art_set), sep='\n')
| 75 | 76 | 1,572 | 1,696 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
5 4
0 1
1 2
2 3
3 4
output:
1
2
3
"""
import sys
sys.setrecursionlimit(int(1e5))
def dfs_Tarjan(current):
global timer
children = 0
visited[current] = True
disc[current] = low[current] = timer
timer += 1
for adj in adj_table[current]:
if not visited[adj]:
parent[adj] = current
children += 1
dfs_Tarjan(adj)
low[current] = min(low[current], low[adj])
if parent[current] == -1 and children > 1:
art_set.add(current)
elif parent[current] != -1 and low[adj] >= disc[current]:
art_set.add(current)
elif adj != parent[current]:
low[current] = min(low[current], disc[adj])
return None
def dfs_init():
for v in range(v_num):
if not visited[v]:
dfs_Tarjan(v)
return None
if __name__ == "__main__":
_input = sys.stdin.readlines()
v_num, e_num = map(int, _input[0].split())
edges = map(lambda x: x.split(), _input[1:])
adj_table = tuple([] for _ in range(v_num))
for edge in edges:
source, target = map(int, edge)
adj_table[source].append(target)
adj_table[target].append(source)
timer = 0
art_set = set()
parent = [-1] * v_num
visited = [False] * v_num
disc, low = ([float("inf")] * v_num for _ in range(2))
dfs_init()
if art_set:
print(*sorted(art_set), sep="\n")
| #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
5 4
0 1
1 2
2 3
3 4
output:
1
2
3
"""
import sys
sys.setrecursionlimit(int(1e5))
def dfs_Tarjan(current, visited, disc, low, parent):
global timer
children = 0
visited[current] = True
disc[current] = low[current] = timer
timer += 1
for adj in adj_table[current]:
if not visited[adj]:
parent[adj] = current
children += 1
dfs_Tarjan(adj, visited, disc, low, parent)
low[current] = min(low[current], low[adj])
if parent[current] == -1 and children > 1:
art_set.add(current)
elif parent[current] != -1 and low[adj] >= disc[current]:
art_set.add(current)
elif adj != parent[current]:
low[current] = min(low[current], disc[adj])
return None
def dfs_init():
parent = [-1] * v_num
visited = [False] * v_num
disc, low = ([float("inf")] * v_num for _ in range(2))
for v in range(v_num):
if not visited[v]:
dfs_Tarjan(v, visited, disc, low, parent)
return None
if __name__ == "__main__":
_input = sys.stdin.readlines()
v_num, e_num = map(int, _input[0].split())
edges = map(lambda x: x.split(), _input[1:])
adj_table = tuple([] for _ in range(v_num))
for edge in edges:
source, target = map(int, edge)
adj_table[source].append(target)
adj_table[target].append(source)
timer = 0
art_set = set()
# generate articulation points set
dfs_init()
if art_set:
print(*sorted(art_set), sep="\n")
| false | 1.315789 | [
"-def dfs_Tarjan(current):",
"+def dfs_Tarjan(current, visited, disc, low, parent):",
"- dfs_Tarjan(adj)",
"+ dfs_Tarjan(adj, visited, disc, low, parent)",
"+ parent = [-1] * v_num",
"+ visited = [False] * v_num",
"+ disc, low = ([float(\"inf\")] * v_num for _ in range(2))",
"- dfs_Tarjan(v)",
"+ dfs_Tarjan(v, visited, disc, low, parent)",
"- parent = [-1] * v_num",
"- visited = [False] * v_num",
"- disc, low = ([float(\"inf\")] * v_num for _ in range(2))",
"+ # generate articulation points set"
] | false | 0.041943 | 0.044417 | 0.944298 | [
"s109837236",
"s785890302"
] |
u850772037 | p02880 | python | s120677965 | s889579006 | 19 | 17 | 3,064 | 2,940 | Accepted | Accepted | 10.53 | import sys
N = int(eval(input()))
a = 1
b = 1
if (N == 1)or(N == 81):
print("Yes")
elif (2 <= N <= 80):
for a in range(1,10):
for b in range(1,10):
if N == a*b:
print("Yes")
sys.exit()
else:
None
print("No")
sys.exit()
elif 82 <= N:
print("No") | N = int(eval(input()))
ans = 0
for a in range(1,10):
for b in range(1,10):
if N == a*b:
ans = 1
if (ans == 1):
print("Yes")
else:
print("No") | 18 | 10 | 355 | 176 | import sys
N = int(eval(input()))
a = 1
b = 1
if (N == 1) or (N == 81):
print("Yes")
elif 2 <= N <= 80:
for a in range(1, 10):
for b in range(1, 10):
if N == a * b:
print("Yes")
sys.exit()
else:
None
print("No")
sys.exit()
elif 82 <= N:
print("No")
| N = int(eval(input()))
ans = 0
for a in range(1, 10):
for b in range(1, 10):
if N == a * b:
ans = 1
if ans == 1:
print("Yes")
else:
print("No")
| false | 44.444444 | [
"-import sys",
"-",
"-a = 1",
"-b = 1",
"-if (N == 1) or (N == 81):",
"+ans = 0",
"+for a in range(1, 10):",
"+ for b in range(1, 10):",
"+ if N == a * b:",
"+ ans = 1",
"+if ans == 1:",
"-elif 2 <= N <= 80:",
"- for a in range(1, 10):",
"- for b in range(1, 10):",
"- if N == a * b:",
"- print(\"Yes\")",
"- sys.exit()",
"- else:",
"- None",
"+else:",
"- sys.exit()",
"-elif 82 <= N:",
"- print(\"No\")"
] | false | 0.058221 | 0.058163 | 1.000998 | [
"s120677965",
"s889579006"
] |
u196579381 | p02714 | python | s970332917 | s713394273 | 1,263 | 138 | 72,512 | 73,476 | Accepted | Accepted | 89.07 | import bisect
N = int(eval(input()))
S = eval(input())
R=[]
G=[]
B=[]
ans=0
for i, s in enumerate(S):
if s == "R":
R.append(i)
elif s == "G":
G.append(i)
else:
B.append(i)
blen=len(B)
for ri in range(len(R)):
for gi in range(len(G)):
x, y = sorted([R[ri], G[gi]])
ans+=blen
bi = bisect.bisect_left(B,2*y-x)
if bi < blen and B[bi] == 2*y-x:
ans -= 1
bi = bisect.bisect_left(B,(x+y)/2)
if bi < blen and B[bi] == (x+y)/2:
ans -= 1
bi = bisect.bisect_left(B, 2 * x - y)
if bi < blen and B[bi] == 2 * x - y:
ans -= 1
print(ans)
| N = int(eval(input()))
S = eval(input())
ans = S.count("R") * S.count("B") * S.count("G")
for i in range(len(S)):
for j in range(i + 1, len(S)):
k = j * 2 - i
if k >= len(S):
break
if S[i] != S[j] and S[j] != S[k] and S[k] != S[i]:
ans -= 1
print(ans) | 34 | 11 | 713 | 301 | import bisect
N = int(eval(input()))
S = eval(input())
R = []
G = []
B = []
ans = 0
for i, s in enumerate(S):
if s == "R":
R.append(i)
elif s == "G":
G.append(i)
else:
B.append(i)
blen = len(B)
for ri in range(len(R)):
for gi in range(len(G)):
x, y = sorted([R[ri], G[gi]])
ans += blen
bi = bisect.bisect_left(B, 2 * y - x)
if bi < blen and B[bi] == 2 * y - x:
ans -= 1
bi = bisect.bisect_left(B, (x + y) / 2)
if bi < blen and B[bi] == (x + y) / 2:
ans -= 1
bi = bisect.bisect_left(B, 2 * x - y)
if bi < blen and B[bi] == 2 * x - y:
ans -= 1
print(ans)
| N = int(eval(input()))
S = eval(input())
ans = S.count("R") * S.count("B") * S.count("G")
for i in range(len(S)):
for j in range(i + 1, len(S)):
k = j * 2 - i
if k >= len(S):
break
if S[i] != S[j] and S[j] != S[k] and S[k] != S[i]:
ans -= 1
print(ans)
| false | 67.647059 | [
"-import bisect",
"-",
"-R = []",
"-G = []",
"-B = []",
"-ans = 0",
"-for i, s in enumerate(S):",
"- if s == \"R\":",
"- R.append(i)",
"- elif s == \"G\":",
"- G.append(i)",
"- else:",
"- B.append(i)",
"-blen = len(B)",
"-for ri in range(len(R)):",
"- for gi in range(len(G)):",
"- x, y = sorted([R[ri], G[gi]])",
"- ans += blen",
"- bi = bisect.bisect_left(B, 2 * y - x)",
"- if bi < blen and B[bi] == 2 * y - x:",
"- ans -= 1",
"- bi = bisect.bisect_left(B, (x + y) / 2)",
"- if bi < blen and B[bi] == (x + y) / 2:",
"- ans -= 1",
"- bi = bisect.bisect_left(B, 2 * x - y)",
"- if bi < blen and B[bi] == 2 * x - y:",
"+ans = S.count(\"R\") * S.count(\"B\") * S.count(\"G\")",
"+for i in range(len(S)):",
"+ for j in range(i + 1, len(S)):",
"+ k = j * 2 - i",
"+ if k >= len(S):",
"+ break",
"+ if S[i] != S[j] and S[j] != S[k] and S[k] != S[i]:"
] | false | 0.08902 | 0.038554 | 2.308985 | [
"s970332917",
"s713394273"
] |
u167988719 | p03330 | python | s922061312 | s225902128 | 737 | 439 | 3,316 | 3,436 | Accepted | Accepted | 40.43 | from collections import Counter
from itertools import permutations
import sys
input = sys.stdin.buffer.readline
N, C = list(map(int, input().split()))
D = [[int(x) for x in input().split()] for _ in range(C)]
cnt = [Counter() for _ in range(3)]
for i in range(N):
c = [int(x)-1 for x in input().split()]
for j in range(3):
cnt[j].update(c[(3-(i+2)+j)%3::3])
ans = 1000*500*500+5
for p in permutations(list(range(C)), 3):
s = 0
for j in range(3):
for k, v in list(cnt[j].items()):
s += D[k][p[j]] * v
ans = min(ans, s)
print(ans) | from collections import Counter
from itertools import permutations
def main():
N, C = list(map(int, input().split()))
D = [[int(x) for x in input().split()] for _ in range(C)]
cnt = [Counter() for _ in range(3)]
for i in range(N):
c = [int(x)-1 for x in input().split()]
for j in range(3):
cnt[j].update(c[(3-(i+2)+j)%3::3])
ans = 1000*500*500+5
for p in permutations(list(range(C)), 3):
s = 0
for j in range(3):
for k, v in list(cnt[j].items()):
s += D[k][p[j]] * v
ans = min(ans, s)
print(ans)
main() | 23 | 25 | 584 | 622 | from collections import Counter
from itertools import permutations
import sys
input = sys.stdin.buffer.readline
N, C = list(map(int, input().split()))
D = [[int(x) for x in input().split()] for _ in range(C)]
cnt = [Counter() for _ in range(3)]
for i in range(N):
c = [int(x) - 1 for x in input().split()]
for j in range(3):
cnt[j].update(c[(3 - (i + 2) + j) % 3 :: 3])
ans = 1000 * 500 * 500 + 5
for p in permutations(list(range(C)), 3):
s = 0
for j in range(3):
for k, v in list(cnt[j].items()):
s += D[k][p[j]] * v
ans = min(ans, s)
print(ans)
| from collections import Counter
from itertools import permutations
def main():
N, C = list(map(int, input().split()))
D = [[int(x) for x in input().split()] for _ in range(C)]
cnt = [Counter() for _ in range(3)]
for i in range(N):
c = [int(x) - 1 for x in input().split()]
for j in range(3):
cnt[j].update(c[(3 - (i + 2) + j) % 3 :: 3])
ans = 1000 * 500 * 500 + 5
for p in permutations(list(range(C)), 3):
s = 0
for j in range(3):
for k, v in list(cnt[j].items()):
s += D[k][p[j]] * v
ans = min(ans, s)
print(ans)
main()
| false | 8 | [
"-import sys",
"-input = sys.stdin.buffer.readline",
"-N, C = list(map(int, input().split()))",
"-D = [[int(x) for x in input().split()] for _ in range(C)]",
"-cnt = [Counter() for _ in range(3)]",
"-for i in range(N):",
"- c = [int(x) - 1 for x in input().split()]",
"- for j in range(3):",
"- cnt[j].update(c[(3 - (i + 2) + j) % 3 :: 3])",
"-ans = 1000 * 500 * 500 + 5",
"-for p in permutations(list(range(C)), 3):",
"- s = 0",
"- for j in range(3):",
"- for k, v in list(cnt[j].items()):",
"- s += D[k][p[j]] * v",
"- ans = min(ans, s)",
"-print(ans)",
"+",
"+def main():",
"+ N, C = list(map(int, input().split()))",
"+ D = [[int(x) for x in input().split()] for _ in range(C)]",
"+ cnt = [Counter() for _ in range(3)]",
"+ for i in range(N):",
"+ c = [int(x) - 1 for x in input().split()]",
"+ for j in range(3):",
"+ cnt[j].update(c[(3 - (i + 2) + j) % 3 :: 3])",
"+ ans = 1000 * 500 * 500 + 5",
"+ for p in permutations(list(range(C)), 3):",
"+ s = 0",
"+ for j in range(3):",
"+ for k, v in list(cnt[j].items()):",
"+ s += D[k][p[j]] * v",
"+ ans = min(ans, s)",
"+ print(ans)",
"+",
"+",
"+main()"
] | false | 0.038635 | 0.039372 | 0.9813 | [
"s922061312",
"s225902128"
] |
u628732336 | p02394 | python | s570461406 | s710374461 | 30 | 20 | 7,716 | 7,716 | Accepted | Accepted | 33.33 | W, H, x, y ,r = [int(i) for i in input().split()]
if x <= 0 or y <= 0:
print("No")
elif W - x >= r and H - y >= r:
print("Yes")
else:
print("No") | W, H, x, y, r = [int(i) for i in input().split()]
if x + r <= W and y - r >= 0 and x - r >= 0 and y + r <= H:
print("Yes")
else:
print("No") | 8 | 6 | 166 | 154 | W, H, x, y, r = [int(i) for i in input().split()]
if x <= 0 or y <= 0:
print("No")
elif W - x >= r and H - y >= r:
print("Yes")
else:
print("No")
| W, H, x, y, r = [int(i) for i in input().split()]
if x + r <= W and y - r >= 0 and x - r >= 0 and y + r <= H:
print("Yes")
else:
print("No")
| false | 25 | [
"-if x <= 0 or y <= 0:",
"- print(\"No\")",
"-elif W - x >= r and H - y >= r:",
"+if x + r <= W and y - r >= 0 and x - r >= 0 and y + r <= H:"
] | false | 0.033782 | 0.052056 | 0.648956 | [
"s570461406",
"s710374461"
] |
u525065967 | p02555 | python | s731062783 | s148490703 | 538 | 30 | 9,128 | 9,116 | Accepted | Accepted | 94.42 | s = int(eval(input()))
MOD = 10**9 + 7
C = [0]*(s + 1)
C[0] = 1
for n in range(3, s+1): # n:[3,s]
for i in range(3, n+1): # i:[3,n], sum(C[0,n-3])
C[n] += C[n-i]
C[n] %= MOD
print((C[s]))
| s = int(eval(input()))
MOD = 10**9 + 7
C = [0]*(s + 1)
C[0] = 1
for n in range(3, s+1): # n:[3,s]
C[n] = (C[n-1] + C[n-3]) % MOD
print((C[s]))
| 9 | 7 | 208 | 145 | s = int(eval(input()))
MOD = 10**9 + 7
C = [0] * (s + 1)
C[0] = 1
for n in range(3, s + 1): # n:[3,s]
for i in range(3, n + 1): # i:[3,n], sum(C[0,n-3])
C[n] += C[n - i]
C[n] %= MOD
print((C[s]))
| s = int(eval(input()))
MOD = 10**9 + 7
C = [0] * (s + 1)
C[0] = 1
for n in range(3, s + 1): # n:[3,s]
C[n] = (C[n - 1] + C[n - 3]) % MOD
print((C[s]))
| false | 22.222222 | [
"- for i in range(3, n + 1): # i:[3,n], sum(C[0,n-3])",
"- C[n] += C[n - i]",
"- C[n] %= MOD",
"+ C[n] = (C[n - 1] + C[n - 3]) % MOD"
] | false | 0.157975 | 0.036323 | 4.349111 | [
"s731062783",
"s148490703"
] |
u200887663 | p03031 | python | s901934488 | s305346416 | 43 | 34 | 9,204 | 9,244 | Accepted | Accepted | 20.93 | #N = int(input())
n, m = list(map(int, input().split()))
#hl = list(map(int, input().split()))
l = [list(map(int, input().split())) for i in range(m)]
pl = list(map(int, input().split()))
count=0
for i in range(2**n):
b = bin(i)
switch = [False for i in range(n)]
boollist=[]
for j in range(n):
if ((i >> j) & 1):
switch[j] = True
for j in range(m):
k = l[j][0]
sl = l[j][1:]
total=0
for sij in sl:
if switch[sij-1]:
total+=1
if total % 2 == pl[j]:
boollist.append(True)
else:
boollist.append(False)
if all(boollist):
count += 1
print(count)
| #m = int(input())
n, m = list(map(int, input().split()))
#al = list(map(int, input().split()))
#al=[list(input()) for i in range(n)]
switch = []
kl = []
for i in range(m):
temp = list(map(int, input().split()))
kl.append(temp[0])
switch.append(temp[1:])
pl = list(map(int, input().split()))
# print(switch)
pattern = [[0 for _ in range(n)] for _1 in range(2**n)]
for i in range(2**n):
for j in range(n):
if ((i >> j) & 1): # 二進数iの下から数えてj桁目が1か否か
pattern[i][j] = 1
ans = 0
for ptnum, spt in enumerate(pattern):
islit = True
for lightnum in range(m):
count = 0
for s in switch[lightnum]:
if spt[s-1] == 1:
count += 1
if count % 2 != pl[lightnum]:
islit = False
break
if islit:
ans += 1
print(ans)
| 28 | 33 | 716 | 855 | # N = int(input())
n, m = list(map(int, input().split()))
# hl = list(map(int, input().split()))
l = [list(map(int, input().split())) for i in range(m)]
pl = list(map(int, input().split()))
count = 0
for i in range(2**n):
b = bin(i)
switch = [False for i in range(n)]
boollist = []
for j in range(n):
if (i >> j) & 1:
switch[j] = True
for j in range(m):
k = l[j][0]
sl = l[j][1:]
total = 0
for sij in sl:
if switch[sij - 1]:
total += 1
if total % 2 == pl[j]:
boollist.append(True)
else:
boollist.append(False)
if all(boollist):
count += 1
print(count)
| # m = int(input())
n, m = list(map(int, input().split()))
# al = list(map(int, input().split()))
# al=[list(input()) for i in range(n)]
switch = []
kl = []
for i in range(m):
temp = list(map(int, input().split()))
kl.append(temp[0])
switch.append(temp[1:])
pl = list(map(int, input().split()))
# print(switch)
pattern = [[0 for _ in range(n)] for _1 in range(2**n)]
for i in range(2**n):
for j in range(n):
if (i >> j) & 1: # 二進数iの下から数えてj桁目が1か否か
pattern[i][j] = 1
ans = 0
for ptnum, spt in enumerate(pattern):
islit = True
for lightnum in range(m):
count = 0
for s in switch[lightnum]:
if spt[s - 1] == 1:
count += 1
if count % 2 != pl[lightnum]:
islit = False
break
if islit:
ans += 1
print(ans)
| false | 15.151515 | [
"-# N = int(input())",
"+# m = int(input())",
"-# hl = list(map(int, input().split()))",
"-l = [list(map(int, input().split())) for i in range(m)]",
"+# al = list(map(int, input().split()))",
"+# al=[list(input()) for i in range(n)]",
"+switch = []",
"+kl = []",
"+for i in range(m):",
"+ temp = list(map(int, input().split()))",
"+ kl.append(temp[0])",
"+ switch.append(temp[1:])",
"-count = 0",
"+# print(switch)",
"+pattern = [[0 for _ in range(n)] for _1 in range(2**n)]",
"- b = bin(i)",
"- switch = [False for i in range(n)]",
"- boollist = []",
"- if (i >> j) & 1:",
"- switch[j] = True",
"- for j in range(m):",
"- k = l[j][0]",
"- sl = l[j][1:]",
"- total = 0",
"- for sij in sl:",
"- if switch[sij - 1]:",
"- total += 1",
"- if total % 2 == pl[j]:",
"- boollist.append(True)",
"- else:",
"- boollist.append(False)",
"- if all(boollist):",
"- count += 1",
"-print(count)",
"+ if (i >> j) & 1: # 二進数iの下から数えてj桁目が1か否か",
"+ pattern[i][j] = 1",
"+ans = 0",
"+for ptnum, spt in enumerate(pattern):",
"+ islit = True",
"+ for lightnum in range(m):",
"+ count = 0",
"+ for s in switch[lightnum]:",
"+ if spt[s - 1] == 1:",
"+ count += 1",
"+ if count % 2 != pl[lightnum]:",
"+ islit = False",
"+ break",
"+ if islit:",
"+ ans += 1",
"+print(ans)"
] | false | 0.038522 | 0.048759 | 0.790047 | [
"s901934488",
"s305346416"
] |
u454557108 | p03274 | python | s862671251 | s046052542 | 226 | 123 | 62,576 | 14,228 | Accepted | Accepted | 45.58 | n,k = list(map(int,input().split()))
x = list(map(int,input().split()))
ans = 10**9
for i in range(n-k+1) :
xs = abs(x[i+k-1]-x[i])
ans = min(ans,xs+abs(x[i]),xs+abs(x[i+k-1]))
print(ans) | import bisect
import sys
n,k = list(map(int,input().split()))
x = list(map(int,input().split()))
index = bisect.bisect_left(x,0)
if x[0] >= 0 :
print((x[k-1]))
sys.exit()
if x[-1] <= 0 :
print((x[n-k]*(-1)))
sys.exit()
ans = 10**9
if min(index+k,n) == index+k :
ans = x[index+k-1]
if max(0,index-k) == index - k :
ans = min(ans,x[index-k]*(-1))
c = 0
for i in range(index,min(index+k,n)) :
c += 1
if i <= n-1 and i-(k-1) <= n-1 and i-(k-1) >= 0 :
ans = min(ans,x[i]*2+x[i-(k-1)]*(-1))
c = 0
for i in range(max(0,index-k),index) :
c += 1
if i <= n-1 and i+(k-1) <= n-1 :
ans = min(ans,x[i]*(-1)*2+x[i+(k-1)])
print(ans) | 9 | 36 | 197 | 686 | n, k = list(map(int, input().split()))
x = list(map(int, input().split()))
ans = 10**9
for i in range(n - k + 1):
xs = abs(x[i + k - 1] - x[i])
ans = min(ans, xs + abs(x[i]), xs + abs(x[i + k - 1]))
print(ans)
| import bisect
import sys
n, k = list(map(int, input().split()))
x = list(map(int, input().split()))
index = bisect.bisect_left(x, 0)
if x[0] >= 0:
print((x[k - 1]))
sys.exit()
if x[-1] <= 0:
print((x[n - k] * (-1)))
sys.exit()
ans = 10**9
if min(index + k, n) == index + k:
ans = x[index + k - 1]
if max(0, index - k) == index - k:
ans = min(ans, x[index - k] * (-1))
c = 0
for i in range(index, min(index + k, n)):
c += 1
if i <= n - 1 and i - (k - 1) <= n - 1 and i - (k - 1) >= 0:
ans = min(ans, x[i] * 2 + x[i - (k - 1)] * (-1))
c = 0
for i in range(max(0, index - k), index):
c += 1
if i <= n - 1 and i + (k - 1) <= n - 1:
ans = min(ans, x[i] * (-1) * 2 + x[i + (k - 1)])
print(ans)
| false | 75 | [
"+import bisect",
"+import sys",
"+",
"+index = bisect.bisect_left(x, 0)",
"+if x[0] >= 0:",
"+ print((x[k - 1]))",
"+ sys.exit()",
"+if x[-1] <= 0:",
"+ print((x[n - k] * (-1)))",
"+ sys.exit()",
"-for i in range(n - k + 1):",
"- xs = abs(x[i + k - 1] - x[i])",
"- ans = min(ans, xs + abs(x[i]), xs + abs(x[i + k - 1]))",
"+if min(index + k, n) == index + k:",
"+ ans = x[index + k - 1]",
"+if max(0, index - k) == index - k:",
"+ ans = min(ans, x[index - k] * (-1))",
"+c = 0",
"+for i in range(index, min(index + k, n)):",
"+ c += 1",
"+ if i <= n - 1 and i - (k - 1) <= n - 1 and i - (k - 1) >= 0:",
"+ ans = min(ans, x[i] * 2 + x[i - (k - 1)] * (-1))",
"+c = 0",
"+for i in range(max(0, index - k), index):",
"+ c += 1",
"+ if i <= n - 1 and i + (k - 1) <= n - 1:",
"+ ans = min(ans, x[i] * (-1) * 2 + x[i + (k - 1)])"
] | false | 0.035966 | 0.045229 | 0.795204 | [
"s862671251",
"s046052542"
] |
u693953100 | p03045 | python | s184634793 | s207120203 | 972 | 758 | 79,008 | 57,996 | Accepted | Accepted | 22.02 | class UnionFind:
def __init__(self, max_size):
self.parent = [i for i in range(max_size+1)]
self.depth = [0 for _ in range(max_size+1)]
self.cnt = [1 for i in range(max_size+1)]
def find(self, x):
if self.parent[x]==x:
return x
else:
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def unite(self,x,y):
x = self.find(x)
y = self.find(y)
if x==y:
return
elif self.depth[x]<self.depth[y]:
self.parent[x] = y
self.cnt[y] += self.cnt[x]
else:
self.parent[y] = x
self.cnt[x]+=self.cnt[y]
if self.depth[x]==self.depth[y]:
self.depth[x]+=1
def same(self, x, y):
return self.find(x)==self.find(y)
def size(self,x):
return self.cnt[self.find(x)]
n,m = list(map(int,input().split()))
utree = UnionFind(n+10)
for _ in range(m):
x,y,z = list(map(int,input().split()))
utree.unite(x,y)
s = {utree.find(i) for i in range(1,n+1)}
print((len(s))) | class UnionFind:
def __init__(self, max_size):
self.parent = [i for i in range(max_size+1)]
self.depth = [0 for _ in range(max_size+1)]
self.cnt = [1 for i in range(max_size+1)]
def find(self, x):
t = x
while t!=self.parent[t]:
t = self.parent[t]
self.parent[x]=t
return t
def unite(self,x,y):
x = self.find(x)
y = self.find(y)
if x==y:
return
elif self.depth[x]<self.depth[y]:
self.parent[x] = y
self.cnt[y] += self.cnt[x]
else:
self.parent[y] = x
self.cnt[x]+=self.cnt[y]
if self.depth[x]==self.depth[y]:
self.depth[x]+=1
def same(self, x, y):
return self.find(x)==self.find(y)
def size(self,x):
return self.cnt[self.find(x)]
n,m = list(map(int,input().split()))
utree = UnionFind(n+10)
for _ in range(m):
x,y,z = list(map(int,input().split()))
utree.unite(x,y)
s = {utree.find(i) for i in range(1,n+1)}
print((len(s))) | 37 | 37 | 1,124 | 1,089 | class UnionFind:
def __init__(self, max_size):
self.parent = [i for i in range(max_size + 1)]
self.depth = [0 for _ in range(max_size + 1)]
self.cnt = [1 for i in range(max_size + 1)]
def find(self, x):
if self.parent[x] == x:
return x
else:
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
elif self.depth[x] < self.depth[y]:
self.parent[x] = y
self.cnt[y] += self.cnt[x]
else:
self.parent[y] = x
self.cnt[x] += self.cnt[y]
if self.depth[x] == self.depth[y]:
self.depth[x] += 1
def same(self, x, y):
return self.find(x) == self.find(y)
def size(self, x):
return self.cnt[self.find(x)]
n, m = list(map(int, input().split()))
utree = UnionFind(n + 10)
for _ in range(m):
x, y, z = list(map(int, input().split()))
utree.unite(x, y)
s = {utree.find(i) for i in range(1, n + 1)}
print((len(s)))
| class UnionFind:
def __init__(self, max_size):
self.parent = [i for i in range(max_size + 1)]
self.depth = [0 for _ in range(max_size + 1)]
self.cnt = [1 for i in range(max_size + 1)]
def find(self, x):
t = x
while t != self.parent[t]:
t = self.parent[t]
self.parent[x] = t
return t
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
elif self.depth[x] < self.depth[y]:
self.parent[x] = y
self.cnt[y] += self.cnt[x]
else:
self.parent[y] = x
self.cnt[x] += self.cnt[y]
if self.depth[x] == self.depth[y]:
self.depth[x] += 1
def same(self, x, y):
return self.find(x) == self.find(y)
def size(self, x):
return self.cnt[self.find(x)]
n, m = list(map(int, input().split()))
utree = UnionFind(n + 10)
for _ in range(m):
x, y, z = list(map(int, input().split()))
utree.unite(x, y)
s = {utree.find(i) for i in range(1, n + 1)}
print((len(s)))
| false | 0 | [
"- if self.parent[x] == x:",
"- return x",
"- else:",
"- self.parent[x] = self.find(self.parent[x])",
"- return self.parent[x]",
"+ t = x",
"+ while t != self.parent[t]:",
"+ t = self.parent[t]",
"+ self.parent[x] = t",
"+ return t"
] | false | 0.053604 | 0.128899 | 0.415865 | [
"s184634793",
"s207120203"
] |
u077291787 | p04034 | python | s951117957 | s289395503 | 192 | 92 | 18,856 | 25,116 | Accepted | Accepted | 52.08 | # AGC002B - Box and Ball
import sys
input = sys.stdin.readline
def main():
N, M = tuple(map(int, input().split()))
X = tuple(tuple(map(int, input().split())) for _ in range(M))
R = [0] * (N + 1) # red ball may be in box i
R[1] = 1
C = [1] * (N + 1) # number of balls in box i (count)
for x, y in X:
if R[x]:
R[y] = 1
C[x] -= 1
C[y] += 1
if C[x] == 0:
R[x] = 0
ans = sum(R[1:])
print(ans)
if __name__ == "__main__":
main() | # AGC002B - Box and Ball
def main():
N, M, *XY = list(map(int, open(0).read().split()))
R = [0] * (N + 1) # red ball may be in box i
R[1] = 1
C = [1] * (N + 1) # number of balls in box i (count)
for x, y in zip(*[iter(XY)] * 2):
R[y] = 1 if R[x] or R[y] else 0 # red ball may move from x to y
C[x] -= 1
C[y] += 1
R[x] = 0 if C[x] == 0 else R[x] # no more ball in x
ans = sum(R[1:])
print(ans)
if __name__ == "__main__":
main() | 23 | 17 | 540 | 506 | # AGC002B - Box and Ball
import sys
input = sys.stdin.readline
def main():
N, M = tuple(map(int, input().split()))
X = tuple(tuple(map(int, input().split())) for _ in range(M))
R = [0] * (N + 1) # red ball may be in box i
R[1] = 1
C = [1] * (N + 1) # number of balls in box i (count)
for x, y in X:
if R[x]:
R[y] = 1
C[x] -= 1
C[y] += 1
if C[x] == 0:
R[x] = 0
ans = sum(R[1:])
print(ans)
if __name__ == "__main__":
main()
| # AGC002B - Box and Ball
def main():
N, M, *XY = list(map(int, open(0).read().split()))
R = [0] * (N + 1) # red ball may be in box i
R[1] = 1
C = [1] * (N + 1) # number of balls in box i (count)
for x, y in zip(*[iter(XY)] * 2):
R[y] = 1 if R[x] or R[y] else 0 # red ball may move from x to y
C[x] -= 1
C[y] += 1
R[x] = 0 if C[x] == 0 else R[x] # no more ball in x
ans = sum(R[1:])
print(ans)
if __name__ == "__main__":
main()
| false | 26.086957 | [
"-import sys",
"-",
"-input = sys.stdin.readline",
"-",
"-",
"- N, M = tuple(map(int, input().split()))",
"- X = tuple(tuple(map(int, input().split())) for _ in range(M))",
"+ N, M, *XY = list(map(int, open(0).read().split()))",
"- for x, y in X:",
"- if R[x]:",
"- R[y] = 1",
"+ for x, y in zip(*[iter(XY)] * 2):",
"+ R[y] = 1 if R[x] or R[y] else 0 # red ball may move from x to y",
"- if C[x] == 0:",
"- R[x] = 0",
"+ R[x] = 0 if C[x] == 0 else R[x] # no more ball in x"
] | false | 0.058831 | 0.036815 | 1.598002 | [
"s951117957",
"s289395503"
] |
u189479417 | p03137 | python | s954897655 | s617408345 | 114 | 86 | 13,968 | 20,624 | Accepted | Accepted | 24.56 | import sys
N, M = list(map(int,input().split()))
if N >= M:
print((0))
sys.exit()
X = list(map(int,input().split()))
X.sort()
D = []
D = [X[i+1] - X[i] for i in range(M-1)]
D.sort(reverse = True)
ans = 0
for i in range(N-1):
ans -= D[i]
ans += X[-1] - X[0]
print(ans) | N, M = list(map(int,input().split()))
X = list(map(int,input().split()))
X.sort()
L = []
for i in range(M-1):
L.append(X[i+1] - X[i])
L.sort()
if M - N <= 0:
print((0))
else:
print((sum(L[:M - N]))) | 15 | 14 | 285 | 216 | import sys
N, M = list(map(int, input().split()))
if N >= M:
print((0))
sys.exit()
X = list(map(int, input().split()))
X.sort()
D = []
D = [X[i + 1] - X[i] for i in range(M - 1)]
D.sort(reverse=True)
ans = 0
for i in range(N - 1):
ans -= D[i]
ans += X[-1] - X[0]
print(ans)
| N, M = list(map(int, input().split()))
X = list(map(int, input().split()))
X.sort()
L = []
for i in range(M - 1):
L.append(X[i + 1] - X[i])
L.sort()
if M - N <= 0:
print((0))
else:
print((sum(L[: M - N])))
| false | 6.666667 | [
"-import sys",
"-",
"-if N >= M:",
"- print((0))",
"- sys.exit()",
"-D = []",
"-D = [X[i + 1] - X[i] for i in range(M - 1)]",
"-D.sort(reverse=True)",
"-ans = 0",
"-for i in range(N - 1):",
"- ans -= D[i]",
"-ans += X[-1] - X[0]",
"-print(ans)",
"+L = []",
"+for i in range(M - 1):",
"+ L.append(X[i + 1] - X[i])",
"+L.sort()",
"+if M - N <= 0:",
"+ print((0))",
"+else:",
"+ print((sum(L[: M - N])))"
] | false | 0.046863 | 0.03683 | 1.272428 | [
"s954897655",
"s617408345"
] |
u136284779 | p02627 | python | s888972656 | s500892863 | 29 | 24 | 8,948 | 9,072 | Accepted | Accepted | 17.24 | n=eval(input())
s=['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z']
if n in s:
print('A')
else:
print('a') | a=eval(input())
print(('a' if a.islower() else 'A')) | 6 | 2 | 165 | 45 | n = eval(input())
s = [
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H",
"I",
"J",
"K",
"L",
"M",
"N",
"O",
"P",
"Q",
"R",
"S",
"T",
"U",
"V",
"W",
"X",
"Y",
"Z",
]
if n in s:
print("A")
else:
print("a")
| a = eval(input())
print(("a" if a.islower() else "A"))
| false | 66.666667 | [
"-n = eval(input())",
"-s = [",
"- \"A\",",
"- \"B\",",
"- \"C\",",
"- \"D\",",
"- \"E\",",
"- \"F\",",
"- \"G\",",
"- \"H\",",
"- \"I\",",
"- \"J\",",
"- \"K\",",
"- \"L\",",
"- \"M\",",
"- \"N\",",
"- \"O\",",
"- \"P\",",
"- \"Q\",",
"- \"R\",",
"- \"S\",",
"- \"T\",",
"- \"U\",",
"- \"V\",",
"- \"W\",",
"- \"X\",",
"- \"Y\",",
"- \"Z\",",
"-]",
"-if n in s:",
"- print(\"A\")",
"-else:",
"- print(\"a\")",
"+a = eval(input())",
"+print((\"a\" if a.islower() else \"A\"))"
] | false | 0.037334 | 0.058394 | 0.639338 | [
"s888972656",
"s500892863"
] |
u340781749 | p03334 | python | s260090144 | s131679645 | 220 | 166 | 9,524 | 9,496 | Accepted | Accepted | 24.55 | from itertools import product
def check_odd(i, j):
return (i + j) % 2 == 0
def check_even(i, j):
return i % 2 == 0
def solve(n, d1, d2):
s1, s2 = 0, 0
while d1 % 4 == 0:
d1 >>= 2
s1 += 1
while d2 % 4 == 0:
d2 >>= 2
s2 += 1
f1 = check_odd if d1 % 2 else check_even
f2 = check_odd if d2 % 2 else check_even
lim = n ** 2
buf = []
cnt = 0
for i, j in product(list(range(2 * n)), repeat=2):
if f1(i >> s1, j >> s1) and f2(i >> s2, j >> s2):
buf.append('{} {}'.format(i, j))
cnt += 1
if cnt == lim:
break
return buf
n, d1, d2 = list(map(int, input().split()))
print(('\n'.join(solve(n, d1, d2))))
| def check_odd(i, j):
return (i + j) % 2 == 0
def check_even(i, j):
return i % 2 == 0
def solve(n, d1, d2):
s1, s2 = 0, 0
while d1 % 4 == 0:
d1 >>= 2
s1 += 1
while d2 % 4 == 0:
d2 >>= 2
s2 += 1
f1 = check_odd if d1 % 2 else check_even
f2 = check_odd if d2 % 2 else check_even
lim = n ** 2
buf = []
cnt = 0
for i in range(2 * n):
_i1 = i >> s1
_i2 = i >> s2
for j in range(2 * n):
if f1(_i1, j >> s1) and f2(_i2, j >> s2):
buf.append('{} {}'.format(i, j))
cnt += 1
if cnt == lim:
return buf
n, d1, d2 = list(map(int, input().split()))
print(('\n'.join(solve(n, d1, d2))))
| 37 | 36 | 763 | 785 | from itertools import product
def check_odd(i, j):
return (i + j) % 2 == 0
def check_even(i, j):
return i % 2 == 0
def solve(n, d1, d2):
s1, s2 = 0, 0
while d1 % 4 == 0:
d1 >>= 2
s1 += 1
while d2 % 4 == 0:
d2 >>= 2
s2 += 1
f1 = check_odd if d1 % 2 else check_even
f2 = check_odd if d2 % 2 else check_even
lim = n**2
buf = []
cnt = 0
for i, j in product(list(range(2 * n)), repeat=2):
if f1(i >> s1, j >> s1) and f2(i >> s2, j >> s2):
buf.append("{} {}".format(i, j))
cnt += 1
if cnt == lim:
break
return buf
n, d1, d2 = list(map(int, input().split()))
print(("\n".join(solve(n, d1, d2))))
| def check_odd(i, j):
return (i + j) % 2 == 0
def check_even(i, j):
return i % 2 == 0
def solve(n, d1, d2):
s1, s2 = 0, 0
while d1 % 4 == 0:
d1 >>= 2
s1 += 1
while d2 % 4 == 0:
d2 >>= 2
s2 += 1
f1 = check_odd if d1 % 2 else check_even
f2 = check_odd if d2 % 2 else check_even
lim = n**2
buf = []
cnt = 0
for i in range(2 * n):
_i1 = i >> s1
_i2 = i >> s2
for j in range(2 * n):
if f1(_i1, j >> s1) and f2(_i2, j >> s2):
buf.append("{} {}".format(i, j))
cnt += 1
if cnt == lim:
return buf
n, d1, d2 = list(map(int, input().split()))
print(("\n".join(solve(n, d1, d2))))
| false | 2.702703 | [
"-from itertools import product",
"-",
"-",
"- for i, j in product(list(range(2 * n)), repeat=2):",
"- if f1(i >> s1, j >> s1) and f2(i >> s2, j >> s2):",
"- buf.append(\"{} {}\".format(i, j))",
"- cnt += 1",
"- if cnt == lim:",
"- break",
"- return buf",
"+ for i in range(2 * n):",
"+ _i1 = i >> s1",
"+ _i2 = i >> s2",
"+ for j in range(2 * n):",
"+ if f1(_i1, j >> s1) and f2(_i2, j >> s2):",
"+ buf.append(\"{} {}\".format(i, j))",
"+ cnt += 1",
"+ if cnt == lim:",
"+ return buf"
] | false | 0.037574 | 0.038583 | 0.97386 | [
"s260090144",
"s131679645"
] |
u241159583 | p02707 | python | s630680683 | s870421027 | 187 | 164 | 33,992 | 34,004 | Accepted | Accepted | 12.3 | from collections import Counter
N = int(eval(input()))
A = Counter(list(map(int, input().split())))
for i in range(1, N+1):
if i in A: print((A[i]))
else: print((0)) | from collections import Counter
n = int(eval(input()))
A = Counter(list(map(int, input().split())))
ans = [0] * n
for x,y in list(A.items()):
ans[x-1] = y
for i in ans: print(i) | 7 | 7 | 166 | 175 | from collections import Counter
N = int(eval(input()))
A = Counter(list(map(int, input().split())))
for i in range(1, N + 1):
if i in A:
print((A[i]))
else:
print((0))
| from collections import Counter
n = int(eval(input()))
A = Counter(list(map(int, input().split())))
ans = [0] * n
for x, y in list(A.items()):
ans[x - 1] = y
for i in ans:
print(i)
| false | 0 | [
"-N = int(eval(input()))",
"+n = int(eval(input()))",
"-for i in range(1, N + 1):",
"- if i in A:",
"- print((A[i]))",
"- else:",
"- print((0))",
"+ans = [0] * n",
"+for x, y in list(A.items()):",
"+ ans[x - 1] = y",
"+for i in ans:",
"+ print(i)"
] | false | 0.046529 | 0.038955 | 1.194423 | [
"s630680683",
"s870421027"
] |
u353919145 | p02699 | python | s837366905 | s769875519 | 24 | 21 | 8,744 | 9,104 | Accepted | Accepted | 12.5 | a, b = [int(a) for a in input().split()]
print(("unsafe" if a <= b else "safe")) | a, b=[int(yy) for yy in input().split()]
if b>=a:
print('unsafe')
else:
print("safe")
| 2 | 5 | 79 | 92 | a, b = [int(a) for a in input().split()]
print(("unsafe" if a <= b else "safe"))
| a, b = [int(yy) for yy in input().split()]
if b >= a:
print("unsafe")
else:
print("safe")
| false | 60 | [
"-a, b = [int(a) for a in input().split()]",
"-print((\"unsafe\" if a <= b else \"safe\"))",
"+a, b = [int(yy) for yy in input().split()]",
"+if b >= a:",
"+ print(\"unsafe\")",
"+else:",
"+ print(\"safe\")"
] | false | 0.040423 | 0.038852 | 1.04043 | [
"s837366905",
"s769875519"
] |
u973055892 | p02642 | python | s751842697 | s294605886 | 305 | 150 | 104,000 | 135,540 | Accepted | Accepted | 50.82 | def main():
n = int(eval(input()))
a = list(map(int, input().split()))
ans = [0] * (max(a) + 1)
length = max(a) + 1
for x in a:
if ans[x] == 0:
for j in range(x, length, x):
ans[j] += 1
else:
ans[x] += 1
print((len(list([x for x in a if ans[x] == 1]))))
if __name__ == '__main__':
main() | import sys
input = sys.stdin.readline
import math
def INT(): return int(eval(input()))
def MAPINT(): return list(map(int, input().split()))
def LMAPINT(): return list(map(int, input().split()))
def STR(): return eval(input())
def MAPSTR(): return list(map(str, input().split()))
def LMAPSTR(): return list(map(str, input().split()))
f_inf = float('inf')
n = INT()
a = sorted(LMAPINT())
length = (max(a) + 1)
ans = [0] * length
for x in a:
# 重複
if ans[x] != 0:
ans[x] = 2
continue
for j in range(x, length, x):
ans[j] += 1
count = 0
for x in a:
if ans[x] == 1:
count += 1
print(count) | 18 | 32 | 347 | 624 | def main():
n = int(eval(input()))
a = list(map(int, input().split()))
ans = [0] * (max(a) + 1)
length = max(a) + 1
for x in a:
if ans[x] == 0:
for j in range(x, length, x):
ans[j] += 1
else:
ans[x] += 1
print((len(list([x for x in a if ans[x] == 1]))))
if __name__ == "__main__":
main()
| import sys
input = sys.stdin.readline
import math
def INT():
return int(eval(input()))
def MAPINT():
return list(map(int, input().split()))
def LMAPINT():
return list(map(int, input().split()))
def STR():
return eval(input())
def MAPSTR():
return list(map(str, input().split()))
def LMAPSTR():
return list(map(str, input().split()))
f_inf = float("inf")
n = INT()
a = sorted(LMAPINT())
length = max(a) + 1
ans = [0] * length
for x in a:
# 重複
if ans[x] != 0:
ans[x] = 2
continue
for j in range(x, length, x):
ans[j] += 1
count = 0
for x in a:
if ans[x] == 1:
count += 1
print(count)
| false | 43.75 | [
"-def main():",
"- n = int(eval(input()))",
"- a = list(map(int, input().split()))",
"- ans = [0] * (max(a) + 1)",
"- length = max(a) + 1",
"- for x in a:",
"- if ans[x] == 0:",
"- for j in range(x, length, x):",
"- ans[j] += 1",
"- else:",
"- ans[x] += 1",
"- print((len(list([x for x in a if ans[x] == 1]))))",
"+import sys",
"+",
"+input = sys.stdin.readline",
"+import math",
"-if __name__ == \"__main__\":",
"- main()",
"+def INT():",
"+ return int(eval(input()))",
"+",
"+",
"+def MAPINT():",
"+ return list(map(int, input().split()))",
"+",
"+",
"+def LMAPINT():",
"+ return list(map(int, input().split()))",
"+",
"+",
"+def STR():",
"+ return eval(input())",
"+",
"+",
"+def MAPSTR():",
"+ return list(map(str, input().split()))",
"+",
"+",
"+def LMAPSTR():",
"+ return list(map(str, input().split()))",
"+",
"+",
"+f_inf = float(\"inf\")",
"+n = INT()",
"+a = sorted(LMAPINT())",
"+length = max(a) + 1",
"+ans = [0] * length",
"+for x in a:",
"+ # 重複",
"+ if ans[x] != 0:",
"+ ans[x] = 2",
"+ continue",
"+ for j in range(x, length, x):",
"+ ans[j] += 1",
"+count = 0",
"+for x in a:",
"+ if ans[x] == 1:",
"+ count += 1",
"+print(count)"
] | false | 0.036354 | 0.040126 | 0.906 | [
"s751842697",
"s294605886"
] |
u434868840 | p03069 | python | s914532064 | s078834392 | 135 | 122 | 5,096 | 5,096 | Accepted | Accepted | 9.63 | N = int(eval(input()))
S = eval(input())
count_if_all_white = 0
for c in S:
if c == "#":
count_if_all_white += 1
l_count = 0
r_count = sum([1 for c in S if c == "."])
count_if_contain_black = l_count+r_count
for c in S:
if c == "#":
l_count += 1
else:
r_count -= 1
count_if_contain_black = min(count_if_contain_black, l_count+r_count)
print((min(count_if_all_white, count_if_contain_black))) | N = int(eval(input()))
S = eval(input())
l_count = 0
r_count = sum([1 for c in S if c == "."])
count_if_contain_black = l_count+r_count
count_if_all_white = 0
for c in S:
if c == "#":
l_count += 1
count_if_all_white += 1
else:
r_count -= 1
count_if_contain_black = min(count_if_contain_black, l_count+r_count)
print((min(count_if_all_white, count_if_contain_black))) | 20 | 17 | 448 | 415 | N = int(eval(input()))
S = eval(input())
count_if_all_white = 0
for c in S:
if c == "#":
count_if_all_white += 1
l_count = 0
r_count = sum([1 for c in S if c == "."])
count_if_contain_black = l_count + r_count
for c in S:
if c == "#":
l_count += 1
else:
r_count -= 1
count_if_contain_black = min(count_if_contain_black, l_count + r_count)
print((min(count_if_all_white, count_if_contain_black)))
| N = int(eval(input()))
S = eval(input())
l_count = 0
r_count = sum([1 for c in S if c == "."])
count_if_contain_black = l_count + r_count
count_if_all_white = 0
for c in S:
if c == "#":
l_count += 1
count_if_all_white += 1
else:
r_count -= 1
count_if_contain_black = min(count_if_contain_black, l_count + r_count)
print((min(count_if_all_white, count_if_contain_black)))
| false | 15 | [
"+l_count = 0",
"+r_count = sum([1 for c in S if c == \".\"])",
"+count_if_contain_black = l_count + r_count",
"+ l_count += 1",
"-l_count = 0",
"-r_count = sum([1 for c in S if c == \".\"])",
"-count_if_contain_black = l_count + r_count",
"-for c in S:",
"- if c == \"#\":",
"- l_count += 1"
] | false | 0.040072 | 0.075054 | 0.533918 | [
"s914532064",
"s078834392"
] |
u371763408 | p03078 | python | s940148353 | s906420380 | 1,981 | 36 | 160,700 | 4,852 | Accepted | Accepted | 98.18 | x,y,z,k=list(map(int,input().split()))
A=list(map(int,input().split()))
B=list(map(int,input().split()))
C=list(map(int,input().split()))
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
tmp=[]
for a in A:
for b in B:
tmp.append(a+b)
tmp.sort(reverse=True)
tmp=tmp[:k+1]
ans=[]
for c in C:
for t in tmp:
ans.append(c+t)
ans.sort(reverse=True)
for i in range(k):
print((ans[i])) | import heapq
x,y,z,K=list(map(int,input().split()))
A=sorted(list(map(int,input().split())),reverse=True)
B=sorted(list(map(int,input().split())),reverse=True)
C=sorted(list(map(int,input().split())),reverse=True)
q=[]
heapq.heappush(q,(-(A[0]+B[0]+C[0]),0,0,0))
S=set()
for n in range(K):
p,i,j,k=heapq.heappop(q)
print((-p))
if i+1<x and ((i+1,j,k) not in S):
S.add((i+1,j,k))
heapq.heappush(q,(-(A[i+1]+B[j]+C[k]),i+1,j,k))
if j+1<y and ((i,j+1,k) not in S):
S.add((i,j+1,k))
heapq.heappush(q,(-(A[i]+B[j+1]+C[k]),i,j+1,k))
if k+1<z and ((i,j,k+1) not in S):
S.add((i,j,k+1))
heapq.heappush(q,(-(A[i]+B[j]+C[k+1]),i,j,k+1)) | 23 | 21 | 422 | 673 | x, y, z, k = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
A.sort(reverse=True)
B.sort(reverse=True)
C.sort(reverse=True)
tmp = []
for a in A:
for b in B:
tmp.append(a + b)
tmp.sort(reverse=True)
tmp = tmp[: k + 1]
ans = []
for c in C:
for t in tmp:
ans.append(c + t)
ans.sort(reverse=True)
for i in range(k):
print((ans[i]))
| import heapq
x, y, z, K = list(map(int, input().split()))
A = sorted(list(map(int, input().split())), reverse=True)
B = sorted(list(map(int, input().split())), reverse=True)
C = sorted(list(map(int, input().split())), reverse=True)
q = []
heapq.heappush(q, (-(A[0] + B[0] + C[0]), 0, 0, 0))
S = set()
for n in range(K):
p, i, j, k = heapq.heappop(q)
print((-p))
if i + 1 < x and ((i + 1, j, k) not in S):
S.add((i + 1, j, k))
heapq.heappush(q, (-(A[i + 1] + B[j] + C[k]), i + 1, j, k))
if j + 1 < y and ((i, j + 1, k) not in S):
S.add((i, j + 1, k))
heapq.heappush(q, (-(A[i] + B[j + 1] + C[k]), i, j + 1, k))
if k + 1 < z and ((i, j, k + 1) not in S):
S.add((i, j, k + 1))
heapq.heappush(q, (-(A[i] + B[j] + C[k + 1]), i, j, k + 1))
| false | 8.695652 | [
"-x, y, z, k = list(map(int, input().split()))",
"-A = list(map(int, input().split()))",
"-B = list(map(int, input().split()))",
"-C = list(map(int, input().split()))",
"-A.sort(reverse=True)",
"-B.sort(reverse=True)",
"-C.sort(reverse=True)",
"-tmp = []",
"-for a in A:",
"- for b in B:",
"- tmp.append(a + b)",
"-tmp.sort(reverse=True)",
"-tmp = tmp[: k + 1]",
"-ans = []",
"-for c in C:",
"- for t in tmp:",
"- ans.append(c + t)",
"-ans.sort(reverse=True)",
"-for i in range(k):",
"- print((ans[i]))",
"+import heapq",
"+",
"+x, y, z, K = list(map(int, input().split()))",
"+A = sorted(list(map(int, input().split())), reverse=True)",
"+B = sorted(list(map(int, input().split())), reverse=True)",
"+C = sorted(list(map(int, input().split())), reverse=True)",
"+q = []",
"+heapq.heappush(q, (-(A[0] + B[0] + C[0]), 0, 0, 0))",
"+S = set()",
"+for n in range(K):",
"+ p, i, j, k = heapq.heappop(q)",
"+ print((-p))",
"+ if i + 1 < x and ((i + 1, j, k) not in S):",
"+ S.add((i + 1, j, k))",
"+ heapq.heappush(q, (-(A[i + 1] + B[j] + C[k]), i + 1, j, k))",
"+ if j + 1 < y and ((i, j + 1, k) not in S):",
"+ S.add((i, j + 1, k))",
"+ heapq.heappush(q, (-(A[i] + B[j + 1] + C[k]), i, j + 1, k))",
"+ if k + 1 < z and ((i, j, k + 1) not in S):",
"+ S.add((i, j, k + 1))",
"+ heapq.heappush(q, (-(A[i] + B[j] + C[k + 1]), i, j, k + 1))"
] | false | 0.107748 | 0.037262 | 2.891652 | [
"s940148353",
"s906420380"
] |
u782685137 | p02659 | python | s508380343 | s255801975 | 27 | 24 | 10,068 | 9,156 | Accepted | Accepted | 11.11 | from decimal import *
a, b = input().split()
print((int(Decimal(a) * Decimal(b)))) | a,b=list(map(int,input().replace('.','').split()))
print((a*b//100)) | 3 | 2 | 82 | 61 | from decimal import *
a, b = input().split()
print((int(Decimal(a) * Decimal(b))))
| a, b = list(map(int, input().replace(".", "").split()))
print((a * b // 100))
| false | 33.333333 | [
"-from decimal import *",
"-",
"-a, b = input().split()",
"-print((int(Decimal(a) * Decimal(b))))",
"+a, b = list(map(int, input().replace(\".\", \"\").split()))",
"+print((a * b // 100))"
] | false | 0.110162 | 0.047175 | 2.335182 | [
"s508380343",
"s255801975"
] |
u588341295 | p03252 | python | s188589577 | s936018223 | 162 | 123 | 3,632 | 3,632 | Accepted | Accepted | 24.07 | # -*- coding: utf-8 -*-
S = eval(input())
T = eval(input())
# 1対1の対応表
start = [-1] * 26
goal = [-1] * 26
for i in range(len(S)):
# アルファベットを0～25の数値に変換
a = ord(S[i]) - ord('a')
b = ord(T[i]) - ord('a')
# 対応表の該当箇所がまだ空いてるかどうか
if start[a] != -1 or goal[b] != -1:
# 埋まっている場合、今回の組み合わせと一致しているかどうか
if start[a] != b or goal[b] != a:
print('No')
exit()
# 空いていれば対応表を埋める
else:
start[a] = b
goal[b] = a
print('Yes') | # -*- coding: utf-8 -*-
S = eval(input())
T = eval(input())
# 1対1の変換表
start = {}
goal = {}
for i in range(len(S)):
s = S[i]
t = T[i]
# 変換表(変換前S)の該当箇所がまだ空いてるかどうか
if s in start:
# 埋まっている場合、今回の組み合わせと一致しているかどうか
if start[s] != t:
print('No')
exit()
# 空いていれば変換表を埋める
else:
start[s] = t
# 変換後Tも同じようにやる
if t in goal:
if goal[t] != s:
print('No')
exit()
else:
goal[t] = s
print('Yes') | 25 | 30 | 501 | 519 | # -*- coding: utf-8 -*-
S = eval(input())
T = eval(input())
# 1対1の対応表
start = [-1] * 26
goal = [-1] * 26
for i in range(len(S)):
# アルファベットを0～25の数値に変換
a = ord(S[i]) - ord("a")
b = ord(T[i]) - ord("a")
# 対応表の該当箇所がまだ空いてるかどうか
if start[a] != -1 or goal[b] != -1:
# 埋まっている場合、今回の組み合わせと一致しているかどうか
if start[a] != b or goal[b] != a:
print("No")
exit()
# 空いていれば対応表を埋める
else:
start[a] = b
goal[b] = a
print("Yes")
| # -*- coding: utf-8 -*-
S = eval(input())
T = eval(input())
# 1対1の変換表
start = {}
goal = {}
for i in range(len(S)):
s = S[i]
t = T[i]
# 変換表(変換前S)の該当箇所がまだ空いてるかどうか
if s in start:
# 埋まっている場合、今回の組み合わせと一致しているかどうか
if start[s] != t:
print("No")
exit()
# 空いていれば変換表を埋める
else:
start[s] = t
# 変換後Tも同じようにやる
if t in goal:
if goal[t] != s:
print("No")
exit()
else:
goal[t] = s
print("Yes")
| false | 16.666667 | [
"-# 1対1の対応表",
"-start = [-1] * 26",
"-goal = [-1] * 26",
"+# 1対1の変換表",
"+start = {}",
"+goal = {}",
"- # アルファベットを0～25の数値に変換",
"- a = ord(S[i]) - ord(\"a\")",
"- b = ord(T[i]) - ord(\"a\")",
"- # 対応表の該当箇所がまだ空いてるかどうか",
"- if start[a] != -1 or goal[b] != -1:",
"+ s = S[i]",
"+ t = T[i]",
"+ # 変換表(変換前S)の該当箇所がまだ空いてるかどうか",
"+ if s in start:",
"- if start[a] != b or goal[b] != a:",
"+ if start[s] != t:",
"- # 空いていれば対応表を埋める",
"+ # 空いていれば変換表を埋める",
"- start[a] = b",
"- goal[b] = a",
"+ start[s] = t",
"+ # 変換後Tも同じようにやる",
"+ if t in goal:",
"+ if goal[t] != s:",
"+ print(\"No\")",
"+ exit()",
"+ else:",
"+ goal[t] = s"
] | false | 0.055244 | 0.054894 | 1.006368 | [
"s188589577",
"s936018223"
] |
u501451051 | p02773 | python | s718360930 | s315584404 | 685 | 485 | 35,216 | 38,764 | Accepted | Accepted | 29.2 | N = int(eval(input()))
S = [eval(input()) for _ in range(N)]
s = {}
for i in S:
if i in s:
s[i] += 1
else:
s[i] = 1
max_val = max(s.values())
tmp = []
for key, value in list(s.items()):
if value == max_val:
tmp.append(key)
for j in sorted(tmp):
print(j) | from collections import defaultdict, Counter
n = int(eval(input()))
lis = [eval(input()) for _ in range(n)]
a = Counter(lis)
tmp = 0
for key, value in list(a.items()):
tmp = max(value, tmp)
ans =[]
for k, v in list(a.items()):
if v == tmp:
ans.append(k)
for i in sorted(ans):
print(i) | 18 | 18 | 277 | 303 | N = int(eval(input()))
S = [eval(input()) for _ in range(N)]
s = {}
for i in S:
if i in s:
s[i] += 1
else:
s[i] = 1
max_val = max(s.values())
tmp = []
for key, value in list(s.items()):
if value == max_val:
tmp.append(key)
for j in sorted(tmp):
print(j)
| from collections import defaultdict, Counter
n = int(eval(input()))
lis = [eval(input()) for _ in range(n)]
a = Counter(lis)
tmp = 0
for key, value in list(a.items()):
tmp = max(value, tmp)
ans = []
for k, v in list(a.items()):
if v == tmp:
ans.append(k)
for i in sorted(ans):
print(i)
| false | 0 | [
"-N = int(eval(input()))",
"-S = [eval(input()) for _ in range(N)]",
"-s = {}",
"-for i in S:",
"- if i in s:",
"- s[i] += 1",
"- else:",
"- s[i] = 1",
"-max_val = max(s.values())",
"-tmp = []",
"-for key, value in list(s.items()):",
"- if value == max_val:",
"- tmp.append(key)",
"-for j in sorted(tmp):",
"- print(j)",
"+from collections import defaultdict, Counter",
"+",
"+n = int(eval(input()))",
"+lis = [eval(input()) for _ in range(n)]",
"+a = Counter(lis)",
"+tmp = 0",
"+for key, value in list(a.items()):",
"+ tmp = max(value, tmp)",
"+ans = []",
"+for k, v in list(a.items()):",
"+ if v == tmp:",
"+ ans.append(k)",
"+for i in sorted(ans):",
"+ print(i)"
] | false | 0.045288 | 0.064808 | 0.698802 | [
"s718360930",
"s315584404"
] |
u745514010 | p03325 | python | s136549847 | s514696884 | 120 | 68 | 4,148 | 9,940 | Accepted | Accepted | 43.33 | n=int(eval(input()))
s=list(map(int,input().split()))
x=0
for i in s:
while i%2==0:
i/=2
x+=1
print(x) | n = int(eval(input()))
alst = list(map(int, input().split()))
ans = 0
for num in alst:
while num % 2 == 0:
num //= 2
ans += 1
print(ans) | 8 | 8 | 123 | 157 | n = int(eval(input()))
s = list(map(int, input().split()))
x = 0
for i in s:
while i % 2 == 0:
i /= 2
x += 1
print(x)
| n = int(eval(input()))
alst = list(map(int, input().split()))
ans = 0
for num in alst:
while num % 2 == 0:
num //= 2
ans += 1
print(ans)
| false | 0 | [
"-s = list(map(int, input().split()))",
"-x = 0",
"-for i in s:",
"- while i % 2 == 0:",
"- i /= 2",
"- x += 1",
"-print(x)",
"+alst = list(map(int, input().split()))",
"+ans = 0",
"+for num in alst:",
"+ while num % 2 == 0:",
"+ num //= 2",
"+ ans += 1",
"+print(ans)"
] | false | 0.037262 | 0.038414 | 0.970018 | [
"s136549847",
"s514696884"
] |
u352394527 | p00448 | python | s547727128 | s027429558 | 7,260 | 3,630 | 6,980 | 6,972 | Accepted | Accepted | 50 | while True:
r,c = list(map(int,input().split()))
if not r:
break
lst = [list(map(int,input().split())) for i in range(r)]
dic = [0 for i in range(2 ** r)]
for i in range(c):
num = 0
for j in range(r):
num *= 2
num += lst[j][i]
dic[num] += 1
ans = 0
for i in range(2 ** r):
ret = 0
for j in range(2 ** r):
num = (i ^ j)
cnt = 0
for k in range(r):
cnt += num % 2
num //= 2
ret += max(cnt, r - cnt) * dic[j]
ans = max(ans, ret)
print(ans)
| def f():
while True:
r,c = list(map(int,input().split()))
if not r:
break
lst = [list(map(int,input().split())) for i in range(r)]
dic = [0 for i in range(2 ** r)]
for i in range(c):
num = 0
for j in range(r):
num *= 2
num += lst[j][i]
dic[num] += 1
ans = 0
for i in range(2 ** r):
ret = 0
for j in range(2 ** r):
num = (i ^ j)
cnt = 0
for k in range(r):
cnt += num % 2
num //= 2
ret += max(cnt, r - cnt) * dic[j]
ans = max(ans, ret)
print(ans)
f()
| 25 | 26 | 551 | 612 | while True:
r, c = list(map(int, input().split()))
if not r:
break
lst = [list(map(int, input().split())) for i in range(r)]
dic = [0 for i in range(2**r)]
for i in range(c):
num = 0
for j in range(r):
num *= 2
num += lst[j][i]
dic[num] += 1
ans = 0
for i in range(2**r):
ret = 0
for j in range(2**r):
num = i ^ j
cnt = 0
for k in range(r):
cnt += num % 2
num //= 2
ret += max(cnt, r - cnt) * dic[j]
ans = max(ans, ret)
print(ans)
| def f():
while True:
r, c = list(map(int, input().split()))
if not r:
break
lst = [list(map(int, input().split())) for i in range(r)]
dic = [0 for i in range(2**r)]
for i in range(c):
num = 0
for j in range(r):
num *= 2
num += lst[j][i]
dic[num] += 1
ans = 0
for i in range(2**r):
ret = 0
for j in range(2**r):
num = i ^ j
cnt = 0
for k in range(r):
cnt += num % 2
num //= 2
ret += max(cnt, r - cnt) * dic[j]
ans = max(ans, ret)
print(ans)
f()
| false | 3.846154 | [
"-while True:",
"- r, c = list(map(int, input().split()))",
"- if not r:",
"- break",
"- lst = [list(map(int, input().split())) for i in range(r)]",
"- dic = [0 for i in range(2**r)]",
"- for i in range(c):",
"- num = 0",
"- for j in range(r):",
"- num *= 2",
"- num += lst[j][i]",
"- dic[num] += 1",
"- ans = 0",
"- for i in range(2**r):",
"- ret = 0",
"- for j in range(2**r):",
"- num = i ^ j",
"- cnt = 0",
"- for k in range(r):",
"- cnt += num % 2",
"- num //= 2",
"- ret += max(cnt, r - cnt) * dic[j]",
"- ans = max(ans, ret)",
"- print(ans)",
"+def f():",
"+ while True:",
"+ r, c = list(map(int, input().split()))",
"+ if not r:",
"+ break",
"+ lst = [list(map(int, input().split())) for i in range(r)]",
"+ dic = [0 for i in range(2**r)]",
"+ for i in range(c):",
"+ num = 0",
"+ for j in range(r):",
"+ num *= 2",
"+ num += lst[j][i]",
"+ dic[num] += 1",
"+ ans = 0",
"+ for i in range(2**r):",
"+ ret = 0",
"+ for j in range(2**r):",
"+ num = i ^ j",
"+ cnt = 0",
"+ for k in range(r):",
"+ cnt += num % 2",
"+ num //= 2",
"+ ret += max(cnt, r - cnt) * dic[j]",
"+ ans = max(ans, ret)",
"+ print(ans)",
"+",
"+",
"+f()"
] | false | 0.03976 | 0.039134 | 1.015994 | [
"s547727128",
"s027429558"
] |
u692336506 | p03163 | python | s768877509 | s334367629 | 292 | 255 | 107,248 | 106,948 | Accepted | Accepted | 12.67 | import numpy as np
INF = 2**60 # 無限大を表す値
N, W = list(map(int, input().split()))
wv = [list(map(int, input().split())) for i in range(N)]
dp = np.full((N+1, W+1), -INF, dtype = np.int64)
dp[0][0] = 0 # 初期条件
for i, (w, v) in enumerate(wv):
dp[i+1] = np.maximum(dp[i+1], dp[i])
dp[i+1][w:] = np.maximum(dp[i+1][w:], dp[i][:-w] + v)
print((np.max(dp[N][:W+1]))) | import numpy as np
INF = 2**60 # 無限大を表す値
N, W = list(map(int, input().split()))
wv = [tuple(map(int, input().split())) for i in range(N)]
dp = np.full((N+1, W+1), -INF, dtype = np.int64)
dp[0][0] = 0 # 初期条件
for i, (w, v) in enumerate(wv):
dp[i+1] = np.maximum(dp[i+1], dp[i])
dp[i+1][w:] = np.maximum(dp[i+1][w:], dp[i][:-w] + v)
print((np.max(dp[N][:W+1]))) | 10 | 10 | 360 | 367 | import numpy as np
INF = 2**60 # 無限大を表す値
N, W = list(map(int, input().split()))
wv = [list(map(int, input().split())) for i in range(N)]
dp = np.full((N + 1, W + 1), -INF, dtype=np.int64)
dp[0][0] = 0 # 初期条件
for i, (w, v) in enumerate(wv):
dp[i + 1] = np.maximum(dp[i + 1], dp[i])
dp[i + 1][w:] = np.maximum(dp[i + 1][w:], dp[i][:-w] + v)
print((np.max(dp[N][: W + 1])))
| import numpy as np
INF = 2**60 # 無限大を表す値
N, W = list(map(int, input().split()))
wv = [tuple(map(int, input().split())) for i in range(N)]
dp = np.full((N + 1, W + 1), -INF, dtype=np.int64)
dp[0][0] = 0 # 初期条件
for i, (w, v) in enumerate(wv):
dp[i + 1] = np.maximum(dp[i + 1], dp[i])
dp[i + 1][w:] = np.maximum(dp[i + 1][w:], dp[i][:-w] + v)
print((np.max(dp[N][: W + 1])))
| false | 0 | [
"-wv = [list(map(int, input().split())) for i in range(N)]",
"+wv = [tuple(map(int, input().split())) for i in range(N)]"
] | false | 0.175016 | 0.175631 | 0.996501 | [
"s768877509",
"s334367629"
] |
u227082700 | p02599 | python | s530309504 | s805438262 | 1,299 | 968 | 207,464 | 305,944 | Accepted | Accepted | 25.48 | n,q=list(map(int,input().split()))
a=list(map(int,input().split()))
for i in range(n):a[i]-=1
queries=[[]for _ in range(n)]
for i in range(q):
l,r=list(map(int,input().split()))
l-=1
r-=1
queries[r].append((l,i))
lastAppeared=[0]*n
bit=[0]*(n+1)
ans=[0]*q
for i in range(n):
x=lastAppeared[a[i]]+1
while x<=n+1:
bit[x-1]-=1
x+=x&-x
x=i+2
while x<=n+1:
bit[x-1]+=1
x+=x&-x
lastAppeared[a[i]]=i+1
for l,ind in queries[i]:
x=i+2
while x:
ans[ind]+=bit[x-1]
x-=x&-x
x=l+1
while x:
ans[ind]-=bit[x-1]
x-=x&-x
print((*ans))
| n,q,*x=list(map(int,open(0).read().split()))
a=x[:n]
queries=[[]for _ in[0]*n]
for i in range(q):
l,r=x[n+i*2],x[n+i*2+1]
l-=1
r-=1
queries[r].append((l,i))
lastAppeared=[0]*n
bit=[0]*(n+1)
ans=[0]*q
for i in range(n):
x=lastAppeared[a[i]-1]+1
while x<=n+1:
bit[x-1]-=1
x+=x&-x
x=i+2
while x<=n+1:
bit[x-1]+=1
x+=x&-x
lastAppeared[a[i]-1]=i+1
for l,ind in queries[i]:
x=i+2
while x:
ans[ind]+=bit[x-1]
x-=x&-x
x=l+1
while x:
ans[ind]-=bit[x-1]
x-=x&-x
print((*ans))
| 32 | 31 | 611 | 564 | n, q = list(map(int, input().split()))
a = list(map(int, input().split()))
for i in range(n):
a[i] -= 1
queries = [[] for _ in range(n)]
for i in range(q):
l, r = list(map(int, input().split()))
l -= 1
r -= 1
queries[r].append((l, i))
lastAppeared = [0] * n
bit = [0] * (n + 1)
ans = [0] * q
for i in range(n):
x = lastAppeared[a[i]] + 1
while x <= n + 1:
bit[x - 1] -= 1
x += x & -x
x = i + 2
while x <= n + 1:
bit[x - 1] += 1
x += x & -x
lastAppeared[a[i]] = i + 1
for l, ind in queries[i]:
x = i + 2
while x:
ans[ind] += bit[x - 1]
x -= x & -x
x = l + 1
while x:
ans[ind] -= bit[x - 1]
x -= x & -x
print((*ans))
| n, q, *x = list(map(int, open(0).read().split()))
a = x[:n]
queries = [[] for _ in [0] * n]
for i in range(q):
l, r = x[n + i * 2], x[n + i * 2 + 1]
l -= 1
r -= 1
queries[r].append((l, i))
lastAppeared = [0] * n
bit = [0] * (n + 1)
ans = [0] * q
for i in range(n):
x = lastAppeared[a[i] - 1] + 1
while x <= n + 1:
bit[x - 1] -= 1
x += x & -x
x = i + 2
while x <= n + 1:
bit[x - 1] += 1
x += x & -x
lastAppeared[a[i] - 1] = i + 1
for l, ind in queries[i]:
x = i + 2
while x:
ans[ind] += bit[x - 1]
x -= x & -x
x = l + 1
while x:
ans[ind] -= bit[x - 1]
x -= x & -x
print((*ans))
| false | 3.125 | [
"-n, q = list(map(int, input().split()))",
"-a = list(map(int, input().split()))",
"-for i in range(n):",
"- a[i] -= 1",
"-queries = [[] for _ in range(n)]",
"+n, q, *x = list(map(int, open(0).read().split()))",
"+a = x[:n]",
"+queries = [[] for _ in [0] * n]",
"- l, r = list(map(int, input().split()))",
"+ l, r = x[n + i * 2], x[n + i * 2 + 1]",
"- x = lastAppeared[a[i]] + 1",
"+ x = lastAppeared[a[i] - 1] + 1",
"- lastAppeared[a[i]] = i + 1",
"+ lastAppeared[a[i] - 1] = i + 1"
] | false | 0.088504 | 0.211101 | 0.419249 | [
"s530309504",
"s805438262"
] |
u576432509 | p03329 | python | s702153026 | s273605022 | 378 | 276 | 3,064 | 3,060 | Accepted | Accepted | 26.98 | n=int(eval(input()))
k9=5
k6=6
n9=9**k9
smin=n
for i9 in range(n9):
ii9=i9
s=0
m=0
astr=""
for ii in range(1,k9+2):
r9=ii9%9
ii9=(ii9-r9)//9
s=s*9+r9
m=m+r9
astr=astr+str(r9)
# print("i9",i9,"astr",astr,"s",s,"m",m)
nr=n-s
nr1=nr
# print("nr",nr,"m",m)
if nr==0:
snra=m
# print(nr,m)
elif nr>0:
snra=m
for jj in range(k6,-1,-1):
nra=nr1//(6**jj)
nr1=nr1%(6**jj)
snra=snra+nra
# print("jj",jj,"nra",nra,"nr1",nr1)
if smin>snra:
smin=snra
print(smin)
| n=int(eval(input()))
res=n
for i in range(n+1):
cc=0
t=i
while t>0:
cc=cc+t%6
t=t//6
t=n-i
while t>0:
cc=cc+t%9
t=t//9
if res>cc:
res=cc
print(res)
| 36 | 17 | 661 | 224 | n = int(eval(input()))
k9 = 5
k6 = 6
n9 = 9**k9
smin = n
for i9 in range(n9):
ii9 = i9
s = 0
m = 0
astr = ""
for ii in range(1, k9 + 2):
r9 = ii9 % 9
ii9 = (ii9 - r9) // 9
s = s * 9 + r9
m = m + r9
astr = astr + str(r9)
# print("i9",i9,"astr",astr,"s",s,"m",m)
nr = n - s
nr1 = nr
# print("nr",nr,"m",m)
if nr == 0:
snra = m
# print(nr,m)
elif nr > 0:
snra = m
for jj in range(k6, -1, -1):
nra = nr1 // (6**jj)
nr1 = nr1 % (6**jj)
snra = snra + nra
# print("jj",jj,"nra",nra,"nr1",nr1)
if smin > snra:
smin = snra
print(smin)
| n = int(eval(input()))
res = n
for i in range(n + 1):
cc = 0
t = i
while t > 0:
cc = cc + t % 6
t = t // 6
t = n - i
while t > 0:
cc = cc + t % 9
t = t // 9
if res > cc:
res = cc
print(res)
| false | 52.777778 | [
"-k9 = 5",
"-k6 = 6",
"-n9 = 9**k9",
"-smin = n",
"-for i9 in range(n9):",
"- ii9 = i9",
"- s = 0",
"- m = 0",
"- astr = \"\"",
"- for ii in range(1, k9 + 2):",
"- r9 = ii9 % 9",
"- ii9 = (ii9 - r9) // 9",
"- s = s * 9 + r9",
"- m = m + r9",
"- astr = astr + str(r9)",
"- # print(\"i9\",i9,\"astr\",astr,\"s\",s,\"m\",m)",
"- nr = n - s",
"- nr1 = nr",
"- # print(\"nr\",nr,\"m\",m)",
"- if nr == 0:",
"- snra = m",
"- # print(nr,m)",
"- elif nr > 0:",
"- snra = m",
"- for jj in range(k6, -1, -1):",
"- nra = nr1 // (6**jj)",
"- nr1 = nr1 % (6**jj)",
"- snra = snra + nra",
"- # print(\"jj\",jj,\"nra\",nra,\"nr1\",nr1)",
"- if smin > snra:",
"- smin = snra",
"-print(smin)",
"+res = n",
"+for i in range(n + 1):",
"+ cc = 0",
"+ t = i",
"+ while t > 0:",
"+ cc = cc + t % 6",
"+ t = t // 6",
"+ t = n - i",
"+ while t > 0:",
"+ cc = cc + t % 9",
"+ t = t // 9",
"+ if res > cc:",
"+ res = cc",
"+print(res)"
] | false | 0.997358 | 0.145753 | 6.842813 | [
"s702153026",
"s273605022"
] |
u094191970 | p02597 | python | s052969658 | s096452387 | 68 | 61 | 9,560 | 9,656 | Accepted | Accepted | 10.29 | n=int(eval(input()))
c=eval(input())
cw=c.count('W')
cr=c.count('R')
ans_s='R'*cr+'W'*cw
cnt=0
for i in range(n):
if c[i]!=ans_s[i]:
cnt+=1
print(((cnt+2-1)//2)) | n=int(eval(input()))
c=eval(input())
r_cnt=c.count('R')
w_cnt=c.count('W')
last_c='R'*r_cnt+'W'*w_cnt
num=0
for i in range(n):
if c[i]!=last_c[i]:
num+=1
print(((num+2-1)//2)) | 14 | 14 | 170 | 184 | n = int(eval(input()))
c = eval(input())
cw = c.count("W")
cr = c.count("R")
ans_s = "R" * cr + "W" * cw
cnt = 0
for i in range(n):
if c[i] != ans_s[i]:
cnt += 1
print(((cnt + 2 - 1) // 2))
| n = int(eval(input()))
c = eval(input())
r_cnt = c.count("R")
w_cnt = c.count("W")
last_c = "R" * r_cnt + "W" * w_cnt
num = 0
for i in range(n):
if c[i] != last_c[i]:
num += 1
print(((num + 2 - 1) // 2))
| false | 0 | [
"-cw = c.count(\"W\")",
"-cr = c.count(\"R\")",
"-ans_s = \"R\" * cr + \"W\" * cw",
"-cnt = 0",
"+r_cnt = c.count(\"R\")",
"+w_cnt = c.count(\"W\")",
"+last_c = \"R\" * r_cnt + \"W\" * w_cnt",
"+num = 0",
"- if c[i] != ans_s[i]:",
"- cnt += 1",
"-print(((cnt + 2 - 1) // 2))",
"+ if c[i] != last_c[i]:",
"+ num += 1",
"+print(((num + 2 - 1) // 2))"
] | false | 0.037572 | 0.039414 | 0.953256 | [
"s052969658",
"s096452387"
] |
u767664985 | p03050 | python | s157458629 | s322166441 | 487 | 145 | 3,316 | 3,268 | Accepted | Accepted | 70.23 | 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(reverse = True)
return divisors
N = int(eval(input()))
div = make_divisors(N)
i = 0
ans = 0
m = div[0]
while m >= 1:
q = N // m
r = N % m
if q == r:
ans += m
i += 1
m = div[i]
else:
m -= 1
print(ans)
| N = int(eval(input()))
ans = 0
div = [] # Nの約数を全列挙してdivとする
for i in range(1, int(N ** 0.5) + 1):
if N % i == 0:
div.append(i)
if i != N // i:
div.append(N // i)
for j in range(len(div)):
if div[j] == 1: # m=0はskip
pass
else:
m = div[j] - 1
if N // m == N % m:
ans += m
print(ans)
| 26 | 19 | 405 | 316 | 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(reverse=True)
return divisors
N = int(eval(input()))
div = make_divisors(N)
i = 0
ans = 0
m = div[0]
while m >= 1:
q = N // m
r = N % m
if q == r:
ans += m
i += 1
m = div[i]
else:
m -= 1
print(ans)
| N = int(eval(input()))
ans = 0
div = [] # Nの約数を全列挙してdivとする
for i in range(1, int(N**0.5) + 1):
if N % i == 0:
div.append(i)
if i != N // i:
div.append(N // i)
for j in range(len(div)):
if div[j] == 1: # m=0はskip
pass
else:
m = div[j] - 1
if N // m == N % m:
ans += m
print(ans)
| false | 26.923077 | [
"-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(reverse=True)",
"- return divisors",
"-",
"-",
"-div = make_divisors(N)",
"-i = 0",
"-m = div[0]",
"-while m >= 1:",
"- q = N // m",
"- r = N % m",
"- if q == r:",
"- ans += m",
"- i += 1",
"- m = div[i]",
"+div = [] # Nの約数を全列挙してdivとする",
"+for i in range(1, int(N**0.5) + 1):",
"+ if N % i == 0:",
"+ div.append(i)",
"+ if i != N // i:",
"+ div.append(N // i)",
"+for j in range(len(div)):",
"+ if div[j] == 1: # m=0はskip",
"+ pass",
"- m -= 1",
"+ m = div[j] - 1",
"+ if N // m == N % m:",
"+ ans += m"
] | false | 0.356259 | 0.188639 | 1.888571 | [
"s157458629",
"s322166441"
] |
u688126754 | p03013 | python | s047920975 | s399830307 | 542 | 254 | 7,848 | 7,780 | Accepted | Accepted | 53.14 | N, M = list(map(int, input().split()))
broken_lst = []
for _ in range(M):
broken_lst.append(int(eval(input())))
counter_arr = [0]*(N+1)
counter_arr[0] = 1
next_broken = -1
if len(broken_lst) != 0:
next_broken = broken_lst.pop(0)
last_broken = -1
for i in range(0, N-1):
flug = 0
if i+1 == next_broken:
flug = 1
# print("p0", i, counter_arr)
elif i+1 == last_broken:
pass
# print("p1",i, counter_arr)
else:
counter_arr[i+1] += counter_arr[i]
counter_arr[i+1] %= 10**9 + 7
# print("p2",i, counter_arr)
if i + 2 == next_broken:
flug = 1
# print("p3",i, counter_arr)
else:
if i == 0 and len(broken_lst) != 0:
if broken_lst[0] == 2 and next_broken == 1:
continue
counter_arr[i+2] += counter_arr[i]
counter_arr[i+2] %= 10**9 + 7
# print("p4",i, counter_arr)
if flug == 1:
last_broken = next_broken
if len(broken_lst) != 0:
next_broken = broken_lst.pop(0)
if last_broken != N - 1:
counter_arr[-1] += counter_arr[-2]
counter_arr[-1] %= 10**9 + 7
print((counter_arr[-1]))
| N, M = list(map(int, input().split()))
broken_lst = [1]*(N+1)
for _ in range(M):
broken_lst[int(eval(input()))] = 0
counter_arr = [0]*(N+1)
counter_arr[0] = 1
for i in range(0, N-1):
counter_arr[i+1] += counter_arr[i] * broken_lst[i+1]
counter_arr[i+1] %= 10**9 + 7
counter_arr[i+2] += counter_arr[i] * broken_lst[i+2]
counter_arr[i+2] %= 10**9 + 7
counter_arr[-1] += counter_arr[-2] * broken_lst[-1]
counter_arr[-1] %= 10**9 + 7
print((counter_arr[-1]))
| 47 | 19 | 1,202 | 484 | N, M = list(map(int, input().split()))
broken_lst = []
for _ in range(M):
broken_lst.append(int(eval(input())))
counter_arr = [0] * (N + 1)
counter_arr[0] = 1
next_broken = -1
if len(broken_lst) != 0:
next_broken = broken_lst.pop(0)
last_broken = -1
for i in range(0, N - 1):
flug = 0
if i + 1 == next_broken:
flug = 1
# print("p0", i, counter_arr)
elif i + 1 == last_broken:
pass
# print("p1",i, counter_arr)
else:
counter_arr[i + 1] += counter_arr[i]
counter_arr[i + 1] %= 10**9 + 7
# print("p2",i, counter_arr)
if i + 2 == next_broken:
flug = 1
# print("p3",i, counter_arr)
else:
if i == 0 and len(broken_lst) != 0:
if broken_lst[0] == 2 and next_broken == 1:
continue
counter_arr[i + 2] += counter_arr[i]
counter_arr[i + 2] %= 10**9 + 7
# print("p4",i, counter_arr)
if flug == 1:
last_broken = next_broken
if len(broken_lst) != 0:
next_broken = broken_lst.pop(0)
if last_broken != N - 1:
counter_arr[-1] += counter_arr[-2]
counter_arr[-1] %= 10**9 + 7
print((counter_arr[-1]))
| N, M = list(map(int, input().split()))
broken_lst = [1] * (N + 1)
for _ in range(M):
broken_lst[int(eval(input()))] = 0
counter_arr = [0] * (N + 1)
counter_arr[0] = 1
for i in range(0, N - 1):
counter_arr[i + 1] += counter_arr[i] * broken_lst[i + 1]
counter_arr[i + 1] %= 10**9 + 7
counter_arr[i + 2] += counter_arr[i] * broken_lst[i + 2]
counter_arr[i + 2] %= 10**9 + 7
counter_arr[-1] += counter_arr[-2] * broken_lst[-1]
counter_arr[-1] %= 10**9 + 7
print((counter_arr[-1]))
| false | 59.574468 | [
"-broken_lst = []",
"+broken_lst = [1] * (N + 1)",
"- broken_lst.append(int(eval(input())))",
"+ broken_lst[int(eval(input()))] = 0",
"-next_broken = -1",
"-if len(broken_lst) != 0:",
"- next_broken = broken_lst.pop(0)",
"-last_broken = -1",
"- flug = 0",
"- if i + 1 == next_broken:",
"- flug = 1",
"- # print(\"p0\", i, counter_arr)",
"- elif i + 1 == last_broken:",
"- pass",
"- # print(\"p1\",i, counter_arr)",
"- else:",
"- counter_arr[i + 1] += counter_arr[i]",
"- counter_arr[i + 1] %= 10**9 + 7",
"- # print(\"p2\",i, counter_arr)",
"- if i + 2 == next_broken:",
"- flug = 1",
"- # print(\"p3\",i, counter_arr)",
"- else:",
"- if i == 0 and len(broken_lst) != 0:",
"- if broken_lst[0] == 2 and next_broken == 1:",
"- continue",
"- counter_arr[i + 2] += counter_arr[i]",
"- counter_arr[i + 2] %= 10**9 + 7",
"- # print(\"p4\",i, counter_arr)",
"- if flug == 1:",
"- last_broken = next_broken",
"- if len(broken_lst) != 0:",
"- next_broken = broken_lst.pop(0)",
"-if last_broken != N - 1:",
"- counter_arr[-1] += counter_arr[-2]",
"+ counter_arr[i + 1] += counter_arr[i] * broken_lst[i + 1]",
"+ counter_arr[i + 1] %= 10**9 + 7",
"+ counter_arr[i + 2] += counter_arr[i] * broken_lst[i + 2]",
"+ counter_arr[i + 2] %= 10**9 + 7",
"+counter_arr[-1] += counter_arr[-2] * broken_lst[-1]"
] | false | 0.071677 | 0.05822 | 1.231147 | [
"s047920975",
"s399830307"
] |
u442877951 | p02937 | python | s340216009 | s255203688 | 382 | 131 | 14,276 | 87,152 | Accepted | Accepted | 65.71 | from bisect import bisect
s = list(eval(input()))
t = list(eval(input()))
lenT = len(t)
lenS = len(s)
alp = []
for i in range(26):
array = []
now = chr(ord('a') + i)
for j in range(lenS):
if s[j] == now:
array.append(j)
alp.append(array)
count,now = 0,-1
for i in range(lenT):
j = ord(t[i])-ord('a')
if alp[j]:
next = bisect(alp[j],now)
if next == len(alp[j]):
count += 1
now = alp[j][0]
else:
now = alp[j][next]
else:
print((-1))
exit()
ans = count*lenS+now+1
print(ans) | from bisect import bisect
s = list(eval(input()))
t = list(eval(input()))
lenT = len(t)
lenS = len(s)
alp = []
for i in range(26):
array = []
now = chr(ord('a') + i)
for j in range(lenS):
if s[j] == now:
array.append(j+1)
alp.append(array)
count,now = 0,0
for i in range(lenT):
j = ord(t[i])-ord('a')
if alp[j]:
next = bisect(alp[j],now)
if next == len(alp[j]):
count += 1
now = alp[j][0]
else:
now = alp[j][next]
else:
print((-1))
exit()
ans = count*lenS+now
print(ans) | 33 | 33 | 556 | 555 | from bisect import bisect
s = list(eval(input()))
t = list(eval(input()))
lenT = len(t)
lenS = len(s)
alp = []
for i in range(26):
array = []
now = chr(ord("a") + i)
for j in range(lenS):
if s[j] == now:
array.append(j)
alp.append(array)
count, now = 0, -1
for i in range(lenT):
j = ord(t[i]) - ord("a")
if alp[j]:
next = bisect(alp[j], now)
if next == len(alp[j]):
count += 1
now = alp[j][0]
else:
now = alp[j][next]
else:
print((-1))
exit()
ans = count * lenS + now + 1
print(ans)
| from bisect import bisect
s = list(eval(input()))
t = list(eval(input()))
lenT = len(t)
lenS = len(s)
alp = []
for i in range(26):
array = []
now = chr(ord("a") + i)
for j in range(lenS):
if s[j] == now:
array.append(j + 1)
alp.append(array)
count, now = 0, 0
for i in range(lenT):
j = ord(t[i]) - ord("a")
if alp[j]:
next = bisect(alp[j], now)
if next == len(alp[j]):
count += 1
now = alp[j][0]
else:
now = alp[j][next]
else:
print((-1))
exit()
ans = count * lenS + now
print(ans)
| false | 0 | [
"- array.append(j)",
"+ array.append(j + 1)",
"-count, now = 0, -1",
"+count, now = 0, 0",
"-ans = count * lenS + now + 1",
"+ans = count * lenS + now"
] | false | 0.068667 | 0.122779 | 0.559278 | [
"s340216009",
"s255203688"
] |
u415325136 | p03292 | python | s887536299 | s858392247 | 19 | 17 | 2,940 | 2,940 | Accepted | Accepted | 10.53 | n = list(map(int, input().split()))
n.sort()
print((n[2]-n[0]))
| n = [int(i) for i in input().split()]
n.sort()
print((int(n[2]-n[0])))
| 3 | 3 | 64 | 71 | n = list(map(int, input().split()))
n.sort()
print((n[2] - n[0]))
| n = [int(i) for i in input().split()]
n.sort()
print((int(n[2] - n[0])))
| false | 0 | [
"-n = list(map(int, input().split()))",
"+n = [int(i) for i in input().split()]",
"-print((n[2] - n[0]))",
"+print((int(n[2] - n[0])))"
] | false | 0.05019 | 0.049951 | 1.004782 | [
"s887536299",
"s858392247"
] |
u729133443 | p03323 | python | s980308845 | s806821532 | 161 | 25 | 38,256 | 8,952 | Accepted | Accepted | 84.47 | s=eval(input());print((':('*(len(s)>3or'9'in s)or'Yay!')) | print((':('*(len(s:=eval(input()))>3or'9'in s)or'Yay!')) | 1 | 1 | 49 | 48 | s = eval(input())
print((":(" * (len(s) > 3 or "9" in s) or "Yay!"))
| print((":(" * (len(s := eval(input())) > 3 or "9" in s) or "Yay!"))
| false | 0 | [
"-s = eval(input())",
"-print((\":(\" * (len(s) > 3 or \"9\" in s) or \"Yay!\"))",
"+print((\":(\" * (len(s := eval(input())) > 3 or \"9\" in s) or \"Yay!\"))"
] | false | 0.036702 | 0.040361 | 0.909349 | [
"s980308845",
"s806821532"
] |
u785578220 | p03062 | python | s628686825 | s522694683 | 234 | 59 | 70,160 | 14,212 | Accepted | Accepted | 74.79 |
n = int(eval(input()))
a = list(map(int,input().split()))
ma = []
pa = []
l =[]
t = 0
k = 0
for i in a:
if i < 0:
ma.append(i)
l.append(i*-1)
k+=1
elif i> 0:
pa.append(i)
l.append(i)
else:
t = 1
s = sum(l)
print((s if t == 1 or k%2==0 else s - 2*min(l))) | #写経
n=eval(input())
a=list(map(int,input().split()))
b=[abs(x)for x in a]
#sum(x<0 for x in a)%2 ここで負の値の個数数えてるのが！
print((sum(b)-2*min(b)if sum(x<0 for x in a)%2 else sum(b))) | 20 | 8 | 298 | 175 | n = int(eval(input()))
a = list(map(int, input().split()))
ma = []
pa = []
l = []
t = 0
k = 0
for i in a:
if i < 0:
ma.append(i)
l.append(i * -1)
k += 1
elif i > 0:
pa.append(i)
l.append(i)
else:
t = 1
s = sum(l)
print((s if t == 1 or k % 2 == 0 else s - 2 * min(l)))
| # 写経
n = eval(input())
a = list(map(int, input().split()))
b = [abs(x) for x in a]
# sum(x<0 for x in a)%2 ここで負の値の個数数えてるのが！
print((sum(b) - 2 * min(b) if sum(x < 0 for x in a) % 2 else sum(b)))
| false | 60 | [
"-n = int(eval(input()))",
"+# 写経",
"+n = eval(input())",
"-ma = []",
"-pa = []",
"-l = []",
"-t = 0",
"-k = 0",
"-for i in a:",
"- if i < 0:",
"- ma.append(i)",
"- l.append(i * -1)",
"- k += 1",
"- elif i > 0:",
"- pa.append(i)",
"- l.append(i)",
"- else:",
"- t = 1",
"-s = sum(l)",
"-print((s if t == 1 or k % 2 == 0 else s - 2 * min(l)))",
"+b = [abs(x) for x in a]",
"+# sum(x<0 for x in a)%2 ここで負の値の個数数えてるのが！",
"+print((sum(b) - 2 * min(b) if sum(x < 0 for x in a) % 2 else sum(b)))"
] | false | 0.040217 | 0.040647 | 0.989413 | [
"s628686825",
"s522694683"
] |
u974485376 | p02546 | python | s632431509 | s841275828 | 31 | 26 | 9,008 | 9,072 | Accepted | Accepted | 16.13 | n=(eval(input()))
if n[-1]== 's':
print((n+"es"))
else:
print((n+'s'))
| n=(eval(input()))
if n.endswith('s'):
print((n+'es'))
else:
print((n+'s'))
| 10 | 10 | 83 | 87 | n = eval(input())
if n[-1] == "s":
print((n + "es"))
else:
print((n + "s"))
| n = eval(input())
if n.endswith("s"):
print((n + "es"))
else:
print((n + "s"))
| false | 0 | [
"-if n[-1] == \"s\":",
"+if n.endswith(\"s\"):"
] | false | 0.043943 | 0.043501 | 1.010159 | [
"s632431509",
"s841275828"
] |
u911537358 | p03168 | python | s555543751 | s204558974 | 350 | 233 | 111,964 | 41,324 | Accepted | Accepted | 33.43 | # @author
import sys
class ICoins:
def solve(self):
n = int(eval(input()))
p = [float(_) for _ in input().split()]
dp = [[0.0] * (n + 1) for _ in range(n + 1)]
# dp[i][j] probability of having i heads after j tosses
dp[0][0] = 1
for j in range(1, n + 1):
for i in range(j + 1):
dp[i][j] = dp[i][j - 1] * (1 - p[j - 1])
if i > 0:
dp[i][j] += dp[i - 1][j - 1] * p[j - 1]
ans = 0
for i in range(n + 1):
if i > n - i:
ans += dp[i][n]
print(ans)
solver = ICoins()
input = sys.stdin.readline
solver.solve()
| # @author
import sys
class ICoins:
def solve(self):
n = int(eval(input()))
p = [float(_) for _ in input().split()]
dp = [0.0] * (n + 1)
# dp[i][j] probability of having i heads after j tosses
dp[0] = 1
for j in range(1, n + 1):
for i in range(j, 0, -1):
dp[i] = dp[i] * (1 - p[j - 1]) + dp[i - 1] * p[j - 1]
dp[0] = dp[0] * (1 - p[j - 1])
ans = 0
for i in range(n + 1):
if i > n - i:
ans += dp[i]
print(ans)
solver = ICoins()
input = sys.stdin.readline
solver.solve()
| 28 | 26 | 697 | 637 | # @author
import sys
class ICoins:
def solve(self):
n = int(eval(input()))
p = [float(_) for _ in input().split()]
dp = [[0.0] * (n + 1) for _ in range(n + 1)]
# dp[i][j] probability of having i heads after j tosses
dp[0][0] = 1
for j in range(1, n + 1):
for i in range(j + 1):
dp[i][j] = dp[i][j - 1] * (1 - p[j - 1])
if i > 0:
dp[i][j] += dp[i - 1][j - 1] * p[j - 1]
ans = 0
for i in range(n + 1):
if i > n - i:
ans += dp[i][n]
print(ans)
solver = ICoins()
input = sys.stdin.readline
solver.solve()
| # @author
import sys
class ICoins:
def solve(self):
n = int(eval(input()))
p = [float(_) for _ in input().split()]
dp = [0.0] * (n + 1)
# dp[i][j] probability of having i heads after j tosses
dp[0] = 1
for j in range(1, n + 1):
for i in range(j, 0, -1):
dp[i] = dp[i] * (1 - p[j - 1]) + dp[i - 1] * p[j - 1]
dp[0] = dp[0] * (1 - p[j - 1])
ans = 0
for i in range(n + 1):
if i > n - i:
ans += dp[i]
print(ans)
solver = ICoins()
input = sys.stdin.readline
solver.solve()
| false | 7.142857 | [
"- dp = [[0.0] * (n + 1) for _ in range(n + 1)]",
"+ dp = [0.0] * (n + 1)",
"- dp[0][0] = 1",
"+ dp[0] = 1",
"- for i in range(j + 1):",
"- dp[i][j] = dp[i][j - 1] * (1 - p[j - 1])",
"- if i > 0:",
"- dp[i][j] += dp[i - 1][j - 1] * p[j - 1]",
"+ for i in range(j, 0, -1):",
"+ dp[i] = dp[i] * (1 - p[j - 1]) + dp[i - 1] * p[j - 1]",
"+ dp[0] = dp[0] * (1 - p[j - 1])",
"- ans += dp[i][n]",
"+ ans += dp[i]"
] | false | 0.061878 | 0.155415 | 0.398146 | [
"s555543751",
"s204558974"
] |
u585482323 | p03693 | python | s502569242 | s429828860 | 207 | 171 | 40,560 | 38,512 | Accepted | Accepted | 17.39 | #!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S(): return list(sys.stdin.readline())[:-1]
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)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
r,g,b = LI()
s = r*100+g*10+b
if s%4 == 0:
print("YES")
else:
print("NO")
return
#Solve
if __name__ == "__main__":
solve()
| #!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S(): return list(sys.stdin.readline())[:-1]
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)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
r,g,b = LI()
ans = ["YES","NO"]
print((ans[((g<<1)+b)&3>0]))
return
#Solve
if __name__ == "__main__":
solve()
| 35 | 32 | 818 | 780 | #!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def I():
return int(sys.stdin.readline())
def LS():
return [list(x) for x in sys.stdin.readline().split()]
def S():
return list(sys.stdin.readline())[:-1]
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)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
r, g, b = LI()
s = r * 100 + g * 10 + b
if s % 4 == 0:
print("YES")
else:
print("NO")
return
# Solve
if __name__ == "__main__":
solve()
| #!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def I():
return int(sys.stdin.readline())
def LS():
return [list(x) for x in sys.stdin.readline().split()]
def S():
return list(sys.stdin.readline())[:-1]
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)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
r, g, b = LI()
ans = ["YES", "NO"]
print((ans[((g << 1) + b) & 3 > 0]))
return
# Solve
if __name__ == "__main__":
solve()
| false | 8.571429 | [
"- s = r * 100 + g * 10 + b",
"- if s % 4 == 0:",
"- print(\"YES\")",
"- else:",
"- print(\"NO\")",
"+ ans = [\"YES\", \"NO\"]",
"+ print((ans[((g << 1) + b) & 3 > 0]))"
] | false | 0.053696 | 0.061541 | 0.872528 | [
"s502569242",
"s429828860"
] |
u272525952 | p02711 | python | s634046941 | s209196315 | 64 | 25 | 61,604 | 9,024 | Accepted | Accepted | 60.94 | n=int(eval(input()))
if str(n).count('7')>0:
print('Yes')
else:
print('No')
| N=eval(input())
if str(N).count('7')!=0:
print('Yes')
else:
print('No')
| 6 | 6 | 80 | 83 | n = int(eval(input()))
if str(n).count("7") > 0:
print("Yes")
else:
print("No")
| N = eval(input())
if str(N).count("7") != 0:
print("Yes")
else:
print("No")
| false | 0 | [
"-n = int(eval(input()))",
"-if str(n).count(\"7\") > 0:",
"+N = eval(input())",
"+if str(N).count(\"7\") != 0:"
] | false | 0.036184 | 0.080926 | 0.447129 | [
"s634046941",
"s209196315"
] |
u691018832 | p03945 | python | s766599872 | s589081152 | 46 | 41 | 3,188 | 3,188 | Accepted | Accepted | 10.87 | s = eval(input())
len_s = len(s)
cnt = 0
for i in range(1, len(s)):
memo_0 = s[i - 1]
if s[i] != memo_0:
cnt += 1
print(cnt)
| s = eval(input())
cnt = 0
for i in range(1, len(s)):
if s[i] != s[i - 1]:
cnt += 1
print(cnt)
| 8 | 6 | 142 | 105 | s = eval(input())
len_s = len(s)
cnt = 0
for i in range(1, len(s)):
memo_0 = s[i - 1]
if s[i] != memo_0:
cnt += 1
print(cnt)
| s = eval(input())
cnt = 0
for i in range(1, len(s)):
if s[i] != s[i - 1]:
cnt += 1
print(cnt)
| false | 25 | [
"-len_s = len(s)",
"- memo_0 = s[i - 1]",
"- if s[i] != memo_0:",
"+ if s[i] != s[i - 1]:"
] | false | 0.035804 | 0.043461 | 0.823817 | [
"s766599872",
"s589081152"
] |
u340781749 | p03097 | python | s486883283 | s612574004 | 189 | 172 | 11,276 | 11,276 | Accepted | Accepted | 8.99 | def split(n, a, b, remain, ai, ans, width):
# print(n, a, b, remain, ai, ans, width)
# print(*(f'{c:5d}' for c in ans))
# print(*(f'{c:05b}' for c in ans))
if width == 2:
ans[ai] = a
ans[ai + 1] = b
return
x = a ^ b
y = x & -x # Rightmost Bit at which is different for a and b
l = y.bit_length() - 1
remain.remove(l)
i = next(iter(remain))
lb = a ^ (1 << i)
ra = lb ^ y
width >>= 1
split(n, a, a ^ (1 << i), remain, ai, ans, width)
split(n, ra, b, remain, ai + width, ans, width)
remain.add(l)
def solve(n, a, b):
if bin(a).count('1') % 2 == bin(b).count('1') % 2:
print('NO')
return
remain = set(range(n))
ans = [0] * (1 << n)
split(n, a, b, remain, 0, ans, 1 << n)
print('YES')
print((*ans))
n, a, b = list(map(int, input().split()))
solve(n, a, b)
| def split(n, a, b, remain, ai, ans, width, l=None):
# print(n, a, b, remain, ai, ans, width)
# print(*(f'{c:5d}' for c in ans))
# print(*(f'{c:05b}' for c in ans))
if width == 2:
ans[ai] = a
ans[ai + 1] = b
return
if l is None:
x = a ^ b
y = x & -x # Rightmost Bit at which is different for a and b
l = y.bit_length() - 1
else:
y = 1 << l
remain.remove(l)
i = next(iter(remain))
lb = a ^ (1 << i)
ra = lb ^ y
width >>= 1
split(n, a, a ^ (1 << i), remain, ai, ans, width, i)
split(n, ra, b, remain, ai + width, ans, width)
remain.add(l)
def solve(n, a, b):
if bin(a).count('1') % 2 == bin(b).count('1') % 2:
print('NO')
return
remain = set(range(n))
ans = [0] * (1 << n)
split(n, a, b, remain, 0, ans, 1 << n)
print('YES')
print((*ans))
n, a, b = list(map(int, input().split()))
solve(n, a, b)
| 34 | 37 | 911 | 984 | def split(n, a, b, remain, ai, ans, width):
# print(n, a, b, remain, ai, ans, width)
# print(*(f'{c:5d}' for c in ans))
# print(*(f'{c:05b}' for c in ans))
if width == 2:
ans[ai] = a
ans[ai + 1] = b
return
x = a ^ b
y = x & -x # Rightmost Bit at which is different for a and b
l = y.bit_length() - 1
remain.remove(l)
i = next(iter(remain))
lb = a ^ (1 << i)
ra = lb ^ y
width >>= 1
split(n, a, a ^ (1 << i), remain, ai, ans, width)
split(n, ra, b, remain, ai + width, ans, width)
remain.add(l)
def solve(n, a, b):
if bin(a).count("1") % 2 == bin(b).count("1") % 2:
print("NO")
return
remain = set(range(n))
ans = [0] * (1 << n)
split(n, a, b, remain, 0, ans, 1 << n)
print("YES")
print((*ans))
n, a, b = list(map(int, input().split()))
solve(n, a, b)
| def split(n, a, b, remain, ai, ans, width, l=None):
# print(n, a, b, remain, ai, ans, width)
# print(*(f'{c:5d}' for c in ans))
# print(*(f'{c:05b}' for c in ans))
if width == 2:
ans[ai] = a
ans[ai + 1] = b
return
if l is None:
x = a ^ b
y = x & -x # Rightmost Bit at which is different for a and b
l = y.bit_length() - 1
else:
y = 1 << l
remain.remove(l)
i = next(iter(remain))
lb = a ^ (1 << i)
ra = lb ^ y
width >>= 1
split(n, a, a ^ (1 << i), remain, ai, ans, width, i)
split(n, ra, b, remain, ai + width, ans, width)
remain.add(l)
def solve(n, a, b):
if bin(a).count("1") % 2 == bin(b).count("1") % 2:
print("NO")
return
remain = set(range(n))
ans = [0] * (1 << n)
split(n, a, b, remain, 0, ans, 1 << n)
print("YES")
print((*ans))
n, a, b = list(map(int, input().split()))
solve(n, a, b)
| false | 8.108108 | [
"-def split(n, a, b, remain, ai, ans, width):",
"+def split(n, a, b, remain, ai, ans, width, l=None):",
"- x = a ^ b",
"- y = x & -x # Rightmost Bit at which is different for a and b",
"- l = y.bit_length() - 1",
"+ if l is None:",
"+ x = a ^ b",
"+ y = x & -x # Rightmost Bit at which is different for a and b",
"+ l = y.bit_length() - 1",
"+ else:",
"+ y = 1 << l",
"- split(n, a, a ^ (1 << i), remain, ai, ans, width)",
"+ split(n, a, a ^ (1 << i), remain, ai, ans, width, i)"
] | false | 0.048454 | 0.067304 | 0.719931 | [
"s486883283",
"s612574004"
] |
u513081876 | p03779 | python | s171561188 | s193484757 | 32 | 25 | 2,940 | 2,940 | Accepted | Accepted | 21.88 | X = int(eval(input()))
t = 1
max_t = (t* (t+1)) // 2
# t=1で1 t=2で 2,3 t= 3で 4, 5, 6 t=4で 7,8,9,10 t=5で 11,12,13,14,15までいける
while max_t < X:
t += 1
max_t = (t* (t+1)) // 2
print(t) | x = int(eval(input()))
check = 0
for i in range(1, 1+x):
check += i
if check >= x:
print(i)
break
| 12 | 7 | 207 | 110 | X = int(eval(input()))
t = 1
max_t = (t * (t + 1)) // 2
# t=1で1 t=2で 2,3 t= 3で 4, 5, 6 t=4で 7,8,9,10 t=5で 11,12,13,14,15までいける
while max_t < X:
t += 1
max_t = (t * (t + 1)) // 2
print(t)
| x = int(eval(input()))
check = 0
for i in range(1, 1 + x):
check += i
if check >= x:
print(i)
break
| false | 41.666667 | [
"-X = int(eval(input()))",
"-t = 1",
"-max_t = (t * (t + 1)) // 2",
"-# t=1で1 t=2で 2,3 t= 3で 4, 5, 6 t=4で 7,8,9,10 t=5で 11,12,13,14,15までいける",
"-while max_t < X:",
"- t += 1",
"- max_t = (t * (t + 1)) // 2",
"-print(t)",
"+x = int(eval(input()))",
"+check = 0",
"+for i in range(1, 1 + x):",
"+ check += i",
"+ if check >= x:",
"+ print(i)",
"+ break"
] | false | 0.043877 | 0.042697 | 1.027634 | [
"s171561188",
"s193484757"
] |
u606045429 | p03716 | python | s948381767 | s896265467 | 290 | 262 | 36,308 | 40,260 | Accepted | Accepted | 9.66 | from heapq import heapify, heappushpop
N, *A = list(map(int, open(0).read().split()))
L, C, R = A[:N], A[N:2 * N], A[2 * N:]
heapify(L)
red = [sum(L)]
for c in C:
red.append(red[-1] + c - heappushpop(L, c))
R = [-r for r in R]
heapify(R)
blue = [sum(R)]
for c in reversed(C):
blue.append(blue[-1] - c - heappushpop(R, -c))
print((max(r + b for r, b in zip(red, reversed(blue)))))
| from heapq import heapify, heappushpop
from itertools import accumulate
N, *A = list(map(int, open(0).read().split()))
L, C, R = A[:N], A[N:2 * N], A[2 * N:]
heapify(L)
F = accumulate([sum(L)] + [c - heappushpop(L, c) for c in C])
R = [-r for r in R]
heapify(R)
B = reversed(list(accumulate([sum(R)] + [- c - heappushpop(R, -c) for c in reversed(C)])))
print((max(f + b for f, b in zip(F, B)))) | 18 | 15 | 402 | 405 | from heapq import heapify, heappushpop
N, *A = list(map(int, open(0).read().split()))
L, C, R = A[:N], A[N : 2 * N], A[2 * N :]
heapify(L)
red = [sum(L)]
for c in C:
red.append(red[-1] + c - heappushpop(L, c))
R = [-r for r in R]
heapify(R)
blue = [sum(R)]
for c in reversed(C):
blue.append(blue[-1] - c - heappushpop(R, -c))
print((max(r + b for r, b in zip(red, reversed(blue)))))
| from heapq import heapify, heappushpop
from itertools import accumulate
N, *A = list(map(int, open(0).read().split()))
L, C, R = A[:N], A[N : 2 * N], A[2 * N :]
heapify(L)
F = accumulate([sum(L)] + [c - heappushpop(L, c) for c in C])
R = [-r for r in R]
heapify(R)
B = reversed(
list(accumulate([sum(R)] + [-c - heappushpop(R, -c) for c in reversed(C)]))
)
print((max(f + b for f, b in zip(F, B))))
| false | 16.666667 | [
"+from itertools import accumulate",
"-red = [sum(L)]",
"-for c in C:",
"- red.append(red[-1] + c - heappushpop(L, c))",
"+F = accumulate([sum(L)] + [c - heappushpop(L, c) for c in C])",
"-blue = [sum(R)]",
"-for c in reversed(C):",
"- blue.append(blue[-1] - c - heappushpop(R, -c))",
"-print((max(r + b for r, b in zip(red, reversed(blue)))))",
"+B = reversed(",
"+ list(accumulate([sum(R)] + [-c - heappushpop(R, -c) for c in reversed(C)]))",
"+)",
"+print((max(f + b for f, b in zip(F, B))))"
] | false | 0.051473 | 0.123156 | 0.417948 | [
"s948381767",
"s896265467"
] |
u025501820 | p03266 | python | s240199683 | s434199890 | 100 | 55 | 4,632 | 4,632 | Accepted | Accepted | 45 | N, K = list(map(int, input().split()))
num = [0 for _ in range(K)]
for i in range(1, N + 1):
num[i % K] += 1
ans = 0
for a in range(K):
b = (K - a) % K
c = (K - a) % K
if (b + c) % K == 0:
ans += num[a] * num[b] * num[c]
print(ans)
| N, K = list(map(int, input().split()))
num = [0 for _ in range(K)]
for i in range(1, N + 1):
num[i % K] += 1
ans = 0
if K % 2 == 0:
ans += num[0] ** 3 + num[K // 2] ** 3
else:
ans += num[0] ** 3
print(ans)
| 13 | 13 | 264 | 227 | N, K = list(map(int, input().split()))
num = [0 for _ in range(K)]
for i in range(1, N + 1):
num[i % K] += 1
ans = 0
for a in range(K):
b = (K - a) % K
c = (K - a) % K
if (b + c) % K == 0:
ans += num[a] * num[b] * num[c]
print(ans)
| N, K = list(map(int, input().split()))
num = [0 for _ in range(K)]
for i in range(1, N + 1):
num[i % K] += 1
ans = 0
if K % 2 == 0:
ans += num[0] ** 3 + num[K // 2] ** 3
else:
ans += num[0] ** 3
print(ans)
| false | 0 | [
"-for a in range(K):",
"- b = (K - a) % K",
"- c = (K - a) % K",
"- if (b + c) % K == 0:",
"- ans += num[a] * num[b] * num[c]",
"+if K % 2 == 0:",
"+ ans += num[0] ** 3 + num[K // 2] ** 3",
"+else:",
"+ ans += num[0] ** 3"
] | false | 0.007487 | 0.111389 | 0.067216 | [
"s240199683",
"s434199890"
] |
u761529120 | p03715 | python | s277019379 | s577300939 | 215 | 86 | 41,456 | 73,572 | Accepted | Accepted | 60 | def main():
H, W = list(map(int, input().split()))
S = H * W
ans = float('inf')
for h1 in range(1,H):
S1 = h1 * W
# 縦に分割する場合
h2 = (H - h1) // 2
S2 = h2 * W
S3 = (H - h1 - h2) * W
ans = min(ans, max(S1,S2,S3) - min(S1,S2,S3))
# 横に分割する場合
w2 = W // 2
w3 = W - w2
S2 = (H - h1) * w2
S3 = (H - h1) * w3
ans = min(ans, max(S1,S2,S3) - min(S1,S2,S3))
for w1 in range(1,W):
S1 = w1 * H
# 横に分割する場合
w2 = (W - w1) // 2
S2 = w2 * H
S3 = (W - w1 - w2) * H
ans = min(ans, max(S1,S2,S3) - min(S1,S2,S3))
# 縦に分割する場合
h2 = H // 2
h3 = H - h2
S2 = (W - w1) * h2
S3 = (W - w1) * h3
ans = min(ans, max(S1,S2,S3) - min(S1,S2,S3))
print(ans)
if __name__ == "__main__":
main() | def main():
H, W = list(map(int, input().split()))
ans = float('inf')
h1, h2, h3 = 0,0,0
w1,w2,w1 = 0,0,0
# 横3に切る場合
h1 = H // 3
h2 = H // 3
h3 = H // 3
if H % 3 == 1:
h3 += 1
elif H % 3 == 2:
h2 += 1
h3 += 1
S = [h1*W,h2*W,h3*W]
ans = min(max(S)-min(S),ans)
# 横2縦1に切る場合
h1 = H // 2
h2 = H // 2
h3 = H
if H % 2 == 1:
h2 += 1
for w in range(1,W):
S = [h1*(W-w),h2*(W-w),h3*w]
ans = min(max(S)-min(S),ans)
# 縦3に切る場合
w1 = W // 3
w2 = W // 3
w3 = W // 3
if W % 3 == 1:
w3 += 1
elif W % 3 == 2:
w2 += 1
w3 += 1
S = [w1*H,w2*H,w3*H]
ans = min(max(S)-min(S),ans)
# 縦1横2に切る場合
w1 = W // 2
w2 = W // 2
w3 = W
if W % 2 == 1:
w2 += 1
for h in range(1,H):
S = [w1*(H-h),w2*(H-h),w3*h]
ans = min(max(S)-min(S),ans)
print(ans)
if __name__ == "__main__":
main() | 40 | 51 | 920 | 1,023 | def main():
H, W = list(map(int, input().split()))
S = H * W
ans = float("inf")
for h1 in range(1, H):
S1 = h1 * W
# 縦に分割する場合
h2 = (H - h1) // 2
S2 = h2 * W
S3 = (H - h1 - h2) * W
ans = min(ans, max(S1, S2, S3) - min(S1, S2, S3))
# 横に分割する場合
w2 = W // 2
w3 = W - w2
S2 = (H - h1) * w2
S3 = (H - h1) * w3
ans = min(ans, max(S1, S2, S3) - min(S1, S2, S3))
for w1 in range(1, W):
S1 = w1 * H
# 横に分割する場合
w2 = (W - w1) // 2
S2 = w2 * H
S3 = (W - w1 - w2) * H
ans = min(ans, max(S1, S2, S3) - min(S1, S2, S3))
# 縦に分割する場合
h2 = H // 2
h3 = H - h2
S2 = (W - w1) * h2
S3 = (W - w1) * h3
ans = min(ans, max(S1, S2, S3) - min(S1, S2, S3))
print(ans)
if __name__ == "__main__":
main()
| def main():
H, W = list(map(int, input().split()))
ans = float("inf")
h1, h2, h3 = 0, 0, 0
w1, w2, w1 = 0, 0, 0
# 横3に切る場合
h1 = H // 3
h2 = H // 3
h3 = H // 3
if H % 3 == 1:
h3 += 1
elif H % 3 == 2:
h2 += 1
h3 += 1
S = [h1 * W, h2 * W, h3 * W]
ans = min(max(S) - min(S), ans)
# 横2縦1に切る場合
h1 = H // 2
h2 = H // 2
h3 = H
if H % 2 == 1:
h2 += 1
for w in range(1, W):
S = [h1 * (W - w), h2 * (W - w), h3 * w]
ans = min(max(S) - min(S), ans)
# 縦3に切る場合
w1 = W // 3
w2 = W // 3
w3 = W // 3
if W % 3 == 1:
w3 += 1
elif W % 3 == 2:
w2 += 1
w3 += 1
S = [w1 * H, w2 * H, w3 * H]
ans = min(max(S) - min(S), ans)
# 縦1横2に切る場合
w1 = W // 2
w2 = W // 2
w3 = W
if W % 2 == 1:
w2 += 1
for h in range(1, H):
S = [w1 * (H - h), w2 * (H - h), w3 * h]
ans = min(max(S) - min(S), ans)
print(ans)
if __name__ == "__main__":
main()
| false | 21.568627 | [
"- S = H * W",
"- for h1 in range(1, H):",
"- S1 = h1 * W",
"- # 縦に分割する場合",
"- h2 = (H - h1) // 2",
"- S2 = h2 * W",
"- S3 = (H - h1 - h2) * W",
"- ans = min(ans, max(S1, S2, S3) - min(S1, S2, S3))",
"- # 横に分割する場合",
"- w2 = W // 2",
"- w3 = W - w2",
"- S2 = (H - h1) * w2",
"- S3 = (H - h1) * w3",
"- ans = min(ans, max(S1, S2, S3) - min(S1, S2, S3))",
"- for w1 in range(1, W):",
"- S1 = w1 * H",
"- # 横に分割する場合",
"- w2 = (W - w1) // 2",
"- S2 = w2 * H",
"- S3 = (W - w1 - w2) * H",
"- ans = min(ans, max(S1, S2, S3) - min(S1, S2, S3))",
"- # 縦に分割する場合",
"- h2 = H // 2",
"- h3 = H - h2",
"- S2 = (W - w1) * h2",
"- S3 = (W - w1) * h3",
"- ans = min(ans, max(S1, S2, S3) - min(S1, S2, S3))",
"+ h1, h2, h3 = 0, 0, 0",
"+ w1, w2, w1 = 0, 0, 0",
"+ # 横3に切る場合",
"+ h1 = H // 3",
"+ h2 = H // 3",
"+ h3 = H // 3",
"+ if H % 3 == 1:",
"+ h3 += 1",
"+ elif H % 3 == 2:",
"+ h2 += 1",
"+ h3 += 1",
"+ S = [h1 * W, h2 * W, h3 * W]",
"+ ans = min(max(S) - min(S), ans)",
"+ # 横2縦1に切る場合",
"+ h1 = H // 2",
"+ h2 = H // 2",
"+ h3 = H",
"+ if H % 2 == 1:",
"+ h2 += 1",
"+ for w in range(1, W):",
"+ S = [h1 * (W - w), h2 * (W - w), h3 * w]",
"+ ans = min(max(S) - min(S), ans)",
"+ # 縦3に切る場合",
"+ w1 = W // 3",
"+ w2 = W // 3",
"+ w3 = W // 3",
"+ if W % 3 == 1:",
"+ w3 += 1",
"+ elif W % 3 == 2:",
"+ w2 += 1",
"+ w3 += 1",
"+ S = [w1 * H, w2 * H, w3 * H]",
"+ ans = min(max(S) - min(S), ans)",
"+ # 縦1横2に切る場合",
"+ w1 = W // 2",
"+ w2 = W // 2",
"+ w3 = W",
"+ if W % 2 == 1:",
"+ w2 += 1",
"+ for h in range(1, H):",
"+ S = [w1 * (H - h), w2 * (H - h), w3 * h]",
"+ ans = min(max(S) - min(S), ans)"
] | false | 0.03834 | 0.040452 | 0.947813 | [
"s277019379",
"s577300939"
] |
u440566786 | p03078 | python | s440837621 | s297865498 | 982 | 262 | 138,508 | 61,748 | Accepted | Accepted | 73.32 | import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda :sys.stdin.readline().rstrip()
def resolve():
x,y,z,k=list(map(int,input().split()))
A=list(map(int,input().split()))
B=list(map(int,input().split()))
C=list(map(int,input().split()))
S=[]
T=[]
from itertools import product
for a,b in product(A,B):
S.append(a+b)
S.sort(reverse=1)
S=S[:k]
for s,c in product(S,C):
T.append(s+c)
T.sort(reverse=1)
for i in range(k):
print((T[i]))
resolve() | import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda :sys.stdin.readline().rstrip()
def resolve():
x,y,z,K=list(map(int,input().split()))
A=sorted(map(int,input().split()),reverse=1)
B=sorted(map(int,input().split()),reverse=1)
C=sorted(map(int,input().split()),reverse=1)
# 1<=i<=x,1<=j<=y,1<=k<=z のうち、ijk<=Kを全て取得する
from itertools import product
ind=[]
for i in range(1,x+1):
if(i>K): break
for j in range(1,y+1):
if(i*j>K): break
for k in range(1,z+1):
if(i*j*k>K): break
ind.append((i-1,j-1,k-1))
S=[]
for i,j,k in ind:
S.append(A[i]+B[j]+C[k])
S.sort(reverse=1)
for i in range(K):
print((S[i]))
resolve() | 23 | 30 | 565 | 802 | import sys
sys.setrecursionlimit(2147483647)
INF = float("inf")
MOD = 10**9 + 7
input = lambda: sys.stdin.readline().rstrip()
def resolve():
x, y, z, k = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
S = []
T = []
from itertools import product
for a, b in product(A, B):
S.append(a + b)
S.sort(reverse=1)
S = S[:k]
for s, c in product(S, C):
T.append(s + c)
T.sort(reverse=1)
for i in range(k):
print((T[i]))
resolve()
| import sys
sys.setrecursionlimit(2147483647)
INF = float("inf")
MOD = 10**9 + 7
input = lambda: sys.stdin.readline().rstrip()
def resolve():
x, y, z, K = list(map(int, input().split()))
A = sorted(map(int, input().split()), reverse=1)
B = sorted(map(int, input().split()), reverse=1)
C = sorted(map(int, input().split()), reverse=1)
# 1<=i<=x,1<=j<=y,1<=k<=z のうち、ijk<=Kを全て取得する
from itertools import product
ind = []
for i in range(1, x + 1):
if i > K:
break
for j in range(1, y + 1):
if i * j > K:
break
for k in range(1, z + 1):
if i * j * k > K:
break
ind.append((i - 1, j - 1, k - 1))
S = []
for i, j, k in ind:
S.append(A[i] + B[j] + C[k])
S.sort(reverse=1)
for i in range(K):
print((S[i]))
resolve()
| false | 23.333333 | [
"- x, y, z, k = list(map(int, input().split()))",
"- A = list(map(int, input().split()))",
"- B = list(map(int, input().split()))",
"- C = list(map(int, input().split()))",
"- S = []",
"- T = []",
"+ x, y, z, K = list(map(int, input().split()))",
"+ A = sorted(map(int, input().split()), reverse=1)",
"+ B = sorted(map(int, input().split()), reverse=1)",
"+ C = sorted(map(int, input().split()), reverse=1)",
"+ # 1<=i<=x,1<=j<=y,1<=k<=z のうち、ijk<=Kを全て取得する",
"- for a, b in product(A, B):",
"- S.append(a + b)",
"+ ind = []",
"+ for i in range(1, x + 1):",
"+ if i > K:",
"+ break",
"+ for j in range(1, y + 1):",
"+ if i * j > K:",
"+ break",
"+ for k in range(1, z + 1):",
"+ if i * j * k > K:",
"+ break",
"+ ind.append((i - 1, j - 1, k - 1))",
"+ S = []",
"+ for i, j, k in ind:",
"+ S.append(A[i] + B[j] + C[k])",
"- S = S[:k]",
"- for s, c in product(S, C):",
"- T.append(s + c)",
"- T.sort(reverse=1)",
"- for i in range(k):",
"- print((T[i]))",
"+ for i in range(K):",
"+ print((S[i]))"
] | false | 0.045722 | 0.03845 | 1.189136 | [
"s440837621",
"s297865498"
] |
u790012205 | p02597 | python | s207465465 | s727929724 | 130 | 35 | 10,712 | 12,060 | Accepted | Accepted | 73.08 | N = int(eval(input()))
c = list(eval(input()))
r, w = 0, 0
r = c.count('R')
a = r
for i in range(N):
if c[i] == 'R':
r -= 1
else:
w += 1
ai = max(r, w)
a = min(a, ai)
print(a) | N = int(eval(input()))
c = list(eval(input()))
r = c.count('R')
rr = c[:r].count('R')
print((r - rr)) | 13 | 5 | 207 | 91 | N = int(eval(input()))
c = list(eval(input()))
r, w = 0, 0
r = c.count("R")
a = r
for i in range(N):
if c[i] == "R":
r -= 1
else:
w += 1
ai = max(r, w)
a = min(a, ai)
print(a)
| N = int(eval(input()))
c = list(eval(input()))
r = c.count("R")
rr = c[:r].count("R")
print((r - rr))
| false | 61.538462 | [
"-r, w = 0, 0",
"-a = r",
"-for i in range(N):",
"- if c[i] == \"R\":",
"- r -= 1",
"- else:",
"- w += 1",
"- ai = max(r, w)",
"- a = min(a, ai)",
"-print(a)",
"+rr = c[:r].count(\"R\")",
"+print((r - rr))"
] | false | 0.041134 | 0.041166 | 0.999219 | [
"s207465465",
"s727929724"
] |
u300968187 | p03386 | python | s507891707 | s958163097 | 20 | 17 | 3,444 | 3,060 | Accepted | Accepted | 15 | a, b, k = list(map(int, input().split()))
if a + 2 * k > 1 + b:
for i in range(a, b + 1):
print(i)
else:
for i in range(a, a + k):
print(i)
for i in range(b - k + 1, b + 1):
print(i) | a, b, k = list(map(int, input().split()))
for i in sorted(list(set(range(a, min(a + k, b + 1))) | set(range(max(a, b - k + 1), b + 1)))):
print(i) | 9 | 3 | 220 | 146 | a, b, k = list(map(int, input().split()))
if a + 2 * k > 1 + b:
for i in range(a, b + 1):
print(i)
else:
for i in range(a, a + k):
print(i)
for i in range(b - k + 1, b + 1):
print(i)
| a, b, k = list(map(int, input().split()))
for i in sorted(
list(set(range(a, min(a + k, b + 1))) | set(range(max(a, b - k + 1), b + 1)))
):
print(i)
| false | 66.666667 | [
"-if a + 2 * k > 1 + b:",
"- for i in range(a, b + 1):",
"- print(i)",
"-else:",
"- for i in range(a, a + k):",
"- print(i)",
"- for i in range(b - k + 1, b + 1):",
"- print(i)",
"+for i in sorted(",
"+ list(set(range(a, min(a + k, b + 1))) | set(range(max(a, b - k + 1), b + 1)))",
"+):",
"+ print(i)"
] | false | 0.048813 | 0.048585 | 1.004682 | [
"s507891707",
"s958163097"
] |
u991567869 | p03103 | python | s113750037 | s879058358 | 470 | 393 | 27,884 | 16,980 | Accepted | Accepted | 16.38 | def main():
n, m = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(n)]
ab.sort()
ans = 0
for i, j in ab:
if m < j:
ans += i*m
break
m -= j
ans += i*j
print(ans)
main() | def main():
n, m = list(map(int, input().split()))
ab = [tuple(map(int, input().split())) for _ in range(n)]
ab.sort()
ans = 0
for i, j in ab:
if m < j:
ans += i*m
break
m -= j
ans += i*j
print(ans)
main() | 18 | 18 | 300 | 301 | def main():
n, m = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(n)]
ab.sort()
ans = 0
for i, j in ab:
if m < j:
ans += i * m
break
m -= j
ans += i * j
print(ans)
main()
| def main():
n, m = list(map(int, input().split()))
ab = [tuple(map(int, input().split())) for _ in range(n)]
ab.sort()
ans = 0
for i, j in ab:
if m < j:
ans += i * m
break
m -= j
ans += i * j
print(ans)
main()
| false | 0 | [
"- ab = [list(map(int, input().split())) for _ in range(n)]",
"+ ab = [tuple(map(int, input().split())) for _ in range(n)]"
] | false | 0.034312 | 0.041208 | 0.83267 | [
"s113750037",
"s879058358"
] |
u850479192 | p02645 | python | s253159073 | s140368547 | 29 | 26 | 9,028 | 8,868 | Accepted | Accepted | 10.34 | s = str(eval(input()))
print((s[0]+s[1]+s[2])) | s = str(eval(input()))
print((s[0:3]))
| 2 | 2 | 39 | 32 | s = str(eval(input()))
print((s[0] + s[1] + s[2]))
| s = str(eval(input()))
print((s[0:3]))
| false | 0 | [
"-print((s[0] + s[1] + s[2]))",
"+print((s[0:3]))"
] | false | 0.042051 | 0.040638 | 1.034763 | [
"s253159073",
"s140368547"
] |
u060793972 | p03854 | python | s459500410 | s936894524 | 68 | 59 | 3,316 | 9,216 | Accepted | Accepted | 13.24 | s=eval(input())
while len(s)>7:
if s[-5:]=='erase' or s[-5:]=='dream':
s=s[:-5]
elif s[-6:]=='eraser':
s=s[:-6]
elif s[-7:]=='dreamer':
s=s[:-7]
else:
break
if s=='' or s=='dreamer' or s=='eraser' or s=='erase' or s=='dream':
print('YES')
else:
print('NO') | s=eval(input())
while len(s)>7:
if s[-5:]=='dream' or s[-5:]=='erase':
s=s[:-5]
elif s[-6:]=='eraser':
s=s[:-6]
elif s[-7:]=='dreamer':
s=s[:-7]
else:
print('NO')
exit()
print(('YES' if s=='erase' or s=='dreamer' or s=='dream' or s=='eraser' or s=='' else 'NO')) | 14 | 12 | 319 | 321 | s = eval(input())
while len(s) > 7:
if s[-5:] == "erase" or s[-5:] == "dream":
s = s[:-5]
elif s[-6:] == "eraser":
s = s[:-6]
elif s[-7:] == "dreamer":
s = s[:-7]
else:
break
if s == "" or s == "dreamer" or s == "eraser" or s == "erase" or s == "dream":
print("YES")
else:
print("NO")
| s = eval(input())
while len(s) > 7:
if s[-5:] == "dream" or s[-5:] == "erase":
s = s[:-5]
elif s[-6:] == "eraser":
s = s[:-6]
elif s[-7:] == "dreamer":
s = s[:-7]
else:
print("NO")
exit()
print(
(
"YES"
if s == "erase" or s == "dreamer" or s == "dream" or s == "eraser" or s == ""
else "NO"
)
)
| false | 14.285714 | [
"- if s[-5:] == \"erase\" or s[-5:] == \"dream\":",
"+ if s[-5:] == \"dream\" or s[-5:] == \"erase\":",
"- break",
"-if s == \"\" or s == \"dreamer\" or s == \"eraser\" or s == \"erase\" or s == \"dream\":",
"- print(\"YES\")",
"-else:",
"- print(\"NO\")",
"+ print(\"NO\")",
"+ exit()",
"+print(",
"+ (",
"+ \"YES\"",
"+ if s == \"erase\" or s == \"dreamer\" or s == \"dream\" or s == \"eraser\" or s == \"\"",
"+ else \"NO\"",
"+ )",
"+)"
] | false | 0.064283 | 0.035889 | 1.791178 | [
"s459500410",
"s936894524"
] |
u581187895 | p03862 | python | s121862449 | s113773931 | 118 | 71 | 14,468 | 14,068 | Accepted | Accepted | 39.83 | N, x = list(map(int, input().split()))
A = list(map(int, input().split()))
ans = 0
for i in range(N-1):
if (A[i]+A[i+1]) > x:
cnt = (A[i]+A[i+1]) - x
ans += cnt
A[i+1] -= cnt
if A[i+1] < 0:
A[i+1] = 0
print(ans) | N, x = list(map(int, input().split()))
A = list(map(int, input().split()))
ans = 0
limit = x
for a in A:
if limit < a:
ans += a - limit
limit = x - limit
else:
limit = x - a
print(ans) | 12 | 12 | 253 | 216 | N, x = list(map(int, input().split()))
A = list(map(int, input().split()))
ans = 0
for i in range(N - 1):
if (A[i] + A[i + 1]) > x:
cnt = (A[i] + A[i + 1]) - x
ans += cnt
A[i + 1] -= cnt
if A[i + 1] < 0:
A[i + 1] = 0
print(ans)
| N, x = list(map(int, input().split()))
A = list(map(int, input().split()))
ans = 0
limit = x
for a in A:
if limit < a:
ans += a - limit
limit = x - limit
else:
limit = x - a
print(ans)
| false | 0 | [
"-for i in range(N - 1):",
"- if (A[i] + A[i + 1]) > x:",
"- cnt = (A[i] + A[i + 1]) - x",
"- ans += cnt",
"- A[i + 1] -= cnt",
"- if A[i + 1] < 0:",
"- A[i + 1] = 0",
"+limit = x",
"+for a in A:",
"+ if limit < a:",
"+ ans += a - limit",
"+ limit = x - limit",
"+ else:",
"+ limit = x - a"
] | false | 0.046551 | 0.045909 | 1.013966 | [
"s121862449",
"s113773931"
] |
u325956328 | p03805 | python | s564139855 | s533245394 | 39 | 28 | 8,052 | 3,316 | Accepted | Accepted | 28.21 | from itertools import permutations
N, M = list(map(int, input().split()))
g = [[0] * N for _ in range(N)]
for i in range(M):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
g[a][b] = 1
g[b][a] = 1
# print(g)
check = set()
path = list(permutations(list(range(N))))
for t in path:
if t[0] != 0:
continue
flag = True
for i in range(N - 1):
if g[t[i]][t[i + 1]] != 1:
flag = False
break
if flag:
check.add(t)
# print(check)
print((len(check)))
| import sys
from collections import defaultdict
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
def main():
N, M = list(map(int, input().split()))
G = defaultdict(lambda: [])
for i in range(M):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
G[a].append(b)
G[b].append(a)
# print(G)
def dfs(v, is_visited):
if sum(is_visited) == N:
return 1
ans = 0
for u in G[v]:
if is_visited[u]:
continue
is_visited[u] = True
ans += dfs(u, is_visited)
is_visited[u] = False
return ans
is_visited = [False] * N
is_visited[0] = True
print((dfs(0, is_visited)))
if __name__ == "__main__":
main()
| 29 | 42 | 542 | 816 | from itertools import permutations
N, M = list(map(int, input().split()))
g = [[0] * N for _ in range(N)]
for i in range(M):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
g[a][b] = 1
g[b][a] = 1
# print(g)
check = set()
path = list(permutations(list(range(N))))
for t in path:
if t[0] != 0:
continue
flag = True
for i in range(N - 1):
if g[t[i]][t[i + 1]] != 1:
flag = False
break
if flag:
check.add(t)
# print(check)
print((len(check)))
| import sys
from collections import defaultdict
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
def main():
N, M = list(map(int, input().split()))
G = defaultdict(lambda: [])
for i in range(M):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
G[a].append(b)
G[b].append(a)
# print(G)
def dfs(v, is_visited):
if sum(is_visited) == N:
return 1
ans = 0
for u in G[v]:
if is_visited[u]:
continue
is_visited[u] = True
ans += dfs(u, is_visited)
is_visited[u] = False
return ans
is_visited = [False] * N
is_visited[0] = True
print((dfs(0, is_visited)))
if __name__ == "__main__":
main()
| false | 30.952381 | [
"-from itertools import permutations",
"+import sys",
"+from collections import defaultdict",
"-N, M = list(map(int, input().split()))",
"-g = [[0] * N for _ in range(N)]",
"-for i in range(M):",
"- a, b = list(map(int, input().split()))",
"- a -= 1",
"- b -= 1",
"- g[a][b] = 1",
"- g[b][a] = 1",
"-# print(g)",
"-check = set()",
"-path = list(permutations(list(range(N))))",
"-for t in path:",
"- if t[0] != 0:",
"- continue",
"- flag = True",
"- for i in range(N - 1):",
"- if g[t[i]][t[i + 1]] != 1:",
"- flag = False",
"- break",
"- if flag:",
"- check.add(t)",
"-# print(check)",
"-print((len(check)))",
"+input = sys.stdin.readline",
"+sys.setrecursionlimit(10**7)",
"+",
"+",
"+def main():",
"+ N, M = list(map(int, input().split()))",
"+ G = defaultdict(lambda: [])",
"+ for i in range(M):",
"+ a, b = list(map(int, input().split()))",
"+ a -= 1",
"+ b -= 1",
"+ G[a].append(b)",
"+ G[b].append(a)",
"+ # print(G)",
"+ def dfs(v, is_visited):",
"+ if sum(is_visited) == N:",
"+ return 1",
"+ ans = 0",
"+ for u in G[v]:",
"+ if is_visited[u]:",
"+ continue",
"+ is_visited[u] = True",
"+ ans += dfs(u, is_visited)",
"+ is_visited[u] = False",
"+ return ans",
"+",
"+ is_visited = [False] * N",
"+ is_visited[0] = True",
"+ print((dfs(0, is_visited)))",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false | 0.159263 | 0.045097 | 3.531563 | [
"s564139855",
"s533245394"
] |
u585482323 | p03545 | python | s602315305 | s106265557 | 186 | 172 | 38,768 | 38,384 | Accepted | Accepted | 7.53 | #!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = SR()
return l
mod = 1000000007
#A
def A():
return
#B
def B():
return
#C
def C():
a,b,c,d = list(map(int, S()))
s = ["-","+"]
for i in range(2):
for j in range(2):
for k in range(2):
if eval(str(a)+s[i]+str(b)+s[j]+str(c)+s[k]+str(d)) == 7:
print((str(a)+s[i]+str(b)+s[j]+str(c)+s[k]+str(d)+"=7"))
quit()
#D
def D():
return
#E
def E():
return
#F
def F():
return
#G
def G():
return
#H
def H():
return
#Solve
if __name__ == "__main__":
C()
| #!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
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)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
a,b,c,d = map(int,input())
l = [b,c,d]
for k in range(1<<3):
s = a
ans = []
for i in range(3):
if k&(1<<i):
ans.append("+")
s += l[i]
else:
ans.append("-")
s -= l[i]
if s == 7:
k = [a]
for i in range(3):
k.append(ans[i])
k.append(l[i])
k.append("=7")
print(*k,sep="")
return
return
#Solve
if __name__ == "__main__":
solve()
| 71 | 53 | 1,372 | 1,324 | #!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI():
return list(map(int, sys.stdin.readline().split()))
def I():
return int(sys.stdin.readline())
def LS():
return list(map(list, sys.stdin.readline().split()))
def S():
return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):
l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):
l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):
l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):
l[i] = SR()
return l
mod = 1000000007
# A
def A():
return
# B
def B():
return
# C
def C():
a, b, c, d = list(map(int, S()))
s = ["-", "+"]
for i in range(2):
for j in range(2):
for k in range(2):
if eval(str(a) + s[i] + str(b) + s[j] + str(c) + s[k] + str(d)) == 7:
print(
(str(a) + s[i] + str(b) + s[j] + str(c) + s[k] + str(d) + "=7")
)
quit()
# D
def D():
return
# E
def E():
return
# F
def F():
return
# G
def G():
return
# H
def H():
return
# Solve
if __name__ == "__main__":
C()
| #!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def I():
return int(sys.stdin.readline())
def LS():
return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
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)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
a, b, c, d = map(int, input())
l = [b, c, d]
for k in range(1 << 3):
s = a
ans = []
for i in range(3):
if k & (1 << i):
ans.append("+")
s += l[i]
else:
ans.append("-")
s -= l[i]
if s == 7:
k = [a]
for i in range(3):
k.append(ans[i])
k.append(l[i])
k.append("=7")
print(*k, sep="")
return
return
# Solve
if __name__ == "__main__":
solve()
| false | 25.352113 | [
"-from collections import defaultdict",
"-from collections import deque",
"+from collections import defaultdict, deque",
"+from itertools import permutations, accumulate",
"-import random",
"- return list(map(int, sys.stdin.readline().split()))",
"+ return [int(x) for x in sys.stdin.readline().split()]",
"- return list(map(list, sys.stdin.readline().split()))",
"+ return [list(x) for x in sys.stdin.readline().split()]",
"- return list(sys.stdin.readline())[:-1]",
"+ res = list(sys.stdin.readline())",
"+ if res[-1] == \"\\n\":",
"+ return res[:-1]",
"+ return res",
"- l = [None for i in range(n)]",
"- for i in range(n):",
"- l[i] = I()",
"- return l",
"+ return [I() for i in range(n)]",
"- l = [None for i in range(n)]",
"- for i in range(n):",
"- l[i] = LI()",
"- return l",
"+ return [LI() for i in range(n)]",
"- l = [None for i in range(n)]",
"- for i in range(n):",
"- l[i] = S()",
"- return l",
"+ return [S() for i in range(n)]",
"- l = [None for i in range(n)]",
"- for i in range(n):",
"- l[i] = SR()",
"- return l",
"+ return [LS() for i in range(n)]",
"+sys.setrecursionlimit(1000000)",
"-# A",
"-def A():",
"- return",
"-# B",
"-def B():",
"- return",
"-",
"-",
"-# C",
"-def C():",
"- a, b, c, d = list(map(int, S()))",
"- s = [\"-\", \"+\"]",
"- for i in range(2):",
"- for j in range(2):",
"- for k in range(2):",
"- if eval(str(a) + s[i] + str(b) + s[j] + str(c) + s[k] + str(d)) == 7:",
"- print(",
"- (str(a) + s[i] + str(b) + s[j] + str(c) + s[k] + str(d) + \"=7\")",
"- )",
"- quit()",
"-",
"-",
"-# D",
"-def D():",
"- return",
"-",
"-",
"-# E",
"-def E():",
"- return",
"-",
"-",
"-# F",
"-def F():",
"- return",
"-",
"-",
"-# G",
"-def G():",
"- return",
"-",
"-",
"-# H",
"-def H():",
"+def solve():",
"+ a, b, c, d = map(int, input())",
"+ l = [b, c, d]",
"+ for k in range(1 << 3):",
"+ s = a",
"+ ans = []",
"+ for i in range(3):",
"+ if k & (1 << i):",
"+ ans.append(\"+\")",
"+ s += l[i]",
"+ else:",
"+ ans.append(\"-\")",
"+ s -= l[i]",
"+ if s == 7:",
"+ k = [a]",
"+ for i in range(3):",
"+ k.append(ans[i])",
"+ k.append(l[i])",
"+ k.append(\"=7\")",
"+ print(*k, sep=\"\")",
"+ return",
"- C()",
"+ solve()"
] | false | 0.038961 | 0.043455 | 0.896572 | [
"s602315305",
"s106265557"
] |
u631277801 | p03241 | python | s875617908 | s345266265 | 25 | 23 | 3,064 | 3,064 | Accepted | Accepted | 8 | import sys
stdin = sys.stdin
sys.setrecursionlimit(10**5)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x)-1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
n,m = li()
# mの約数を求める
i = 1
div = []
while i*i <= m:
if m%i == 0:
div.append(i)
div.append(m//i)
i += 1
ans = 1
for d in div:
if m//d >= n:
ans = max(ans, d)
print(ans) | import sys
stdin = sys.stdin
sys.setrecursionlimit(10**5)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x)-1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
def divisors(m: int):
i = 1
div = []
while i*i <= m:
if m%i == 0:
div.append(i)
div.append(m//i)
i += 1
return list(set(div))
n,m = li()
divs = divisors(m)
ans = 1
for di in divs:
if n*di <= m:
ans = max(ans, di)
print(ans) | 31 | 35 | 680 | 766 | import sys
stdin = sys.stdin
sys.setrecursionlimit(10**5)
def li():
return list(map(int, stdin.readline().split()))
def li_():
return [int(x) - 1 for x in stdin.readline().split()]
def lf():
return list(map(float, stdin.readline().split()))
def ls():
return stdin.readline().split()
def ns():
return stdin.readline().rstrip()
def lc():
return list(ns())
def ni():
return int(stdin.readline())
def nf():
return float(stdin.readline())
n, m = li()
# mの約数を求める
i = 1
div = []
while i * i <= m:
if m % i == 0:
div.append(i)
div.append(m // i)
i += 1
ans = 1
for d in div:
if m // d >= n:
ans = max(ans, d)
print(ans)
| import sys
stdin = sys.stdin
sys.setrecursionlimit(10**5)
def li():
return list(map(int, stdin.readline().split()))
def li_():
return [int(x) - 1 for x in stdin.readline().split()]
def lf():
return list(map(float, stdin.readline().split()))
def ls():
return stdin.readline().split()
def ns():
return stdin.readline().rstrip()
def lc():
return list(ns())
def ni():
return int(stdin.readline())
def nf():
return float(stdin.readline())
def divisors(m: int):
i = 1
div = []
while i * i <= m:
if m % i == 0:
div.append(i)
div.append(m // i)
i += 1
return list(set(div))
n, m = li()
divs = divisors(m)
ans = 1
for di in divs:
if n * di <= m:
ans = max(ans, di)
print(ans)
| false | 11.428571 | [
"+def divisors(m: int):",
"+ i = 1",
"+ div = []",
"+ while i * i <= m:",
"+ if m % i == 0:",
"+ div.append(i)",
"+ div.append(m // i)",
"+ i += 1",
"+ return list(set(div))",
"+",
"+",
"-# mの約数を求める",
"-i = 1",
"-div = []",
"-while i * i <= m:",
"- if m % i == 0:",
"- div.append(i)",
"- div.append(m // i)",
"- i += 1",
"+divs = divisors(m)",
"-for d in div:",
"- if m // d >= n:",
"- ans = max(ans, d)",
"+for di in divs:",
"+ if n * di <= m:",
"+ ans = max(ans, di)"
] | false | 0.05068 | 0.053127 | 0.953943 | [
"s875617908",
"s345266265"
] |
u492910842 | p02881 | python | s240634102 | s443689732 | 77 | 69 | 73,252 | 63,108 | Accepted | Accepted | 10.39 | import math
n=int(eval(input()))
for i in reversed(list(range(1,int(math.sqrt(n))+1))):
if n%i == 0:
ans = i+n//i-2
break
print(ans)
| import math
n=int(eval(input()))
r=int(math.sqrt(n))
while n%r!=0:
r-=1
print((n//r+r-2))
| 8 | 8 | 139 | 93 | import math
n = int(eval(input()))
for i in reversed(list(range(1, int(math.sqrt(n)) + 1))):
if n % i == 0:
ans = i + n // i - 2
break
print(ans)
| import math
n = int(eval(input()))
r = int(math.sqrt(n))
while n % r != 0:
r -= 1
print((n // r + r - 2))
| false | 0 | [
"-for i in reversed(list(range(1, int(math.sqrt(n)) + 1))):",
"- if n % i == 0:",
"- ans = i + n // i - 2",
"- break",
"-print(ans)",
"+r = int(math.sqrt(n))",
"+while n % r != 0:",
"+ r -= 1",
"+print((n // r + r - 2))"
] | false | 0.051511 | 0.045295 | 1.137243 | [
"s240634102",
"s443689732"
] |
u894258749 | p02960 | python | s976079092 | s865239971 | 1,948 | 572 | 3,188 | 62,172 | Accepted | Accepted | 70.64 | MOD = 10**9 + 7
S = eval(input())
cur = [0] * 13
cur[0] = 1
r = 1
base = 0
for i in range(len(S)):
s = S[-(i+1)]
if s == '?':
prev = cur
cur = [sum(prev)] * 13
for m in range(13):
for d in range(10,13):
cur[(m + r*d) % 13] -= prev[m]
for m in range(13):
cur[m] %= MOD
else:
base = (base + r*int(s)) % 13
r = (10 * r) % 13
print((cur[(5-base) % 13])) | s = eval(input())
n = len(s)
MOD = 10**9 + 7
dp = [ [0]*13 for _ in range(n+1) ]
dp[0][0] = 1
for i in range(n):
if s[i] == '?':
c = -1
else:
c = int(s[i])
for j in range(10):
if c != -1 and c != j:
continue
for ki in range(13):
dp[i+1][(ki*10 + j) % 13] += dp[i][ki]
for j in range(13):
dp[i+1][j] %= MOD
print((dp[n][5])) | 23 | 20 | 462 | 416 | MOD = 10**9 + 7
S = eval(input())
cur = [0] * 13
cur[0] = 1
r = 1
base = 0
for i in range(len(S)):
s = S[-(i + 1)]
if s == "?":
prev = cur
cur = [sum(prev)] * 13
for m in range(13):
for d in range(10, 13):
cur[(m + r * d) % 13] -= prev[m]
for m in range(13):
cur[m] %= MOD
else:
base = (base + r * int(s)) % 13
r = (10 * r) % 13
print((cur[(5 - base) % 13]))
| s = eval(input())
n = len(s)
MOD = 10**9 + 7
dp = [[0] * 13 for _ in range(n + 1)]
dp[0][0] = 1
for i in range(n):
if s[i] == "?":
c = -1
else:
c = int(s[i])
for j in range(10):
if c != -1 and c != j:
continue
for ki in range(13):
dp[i + 1][(ki * 10 + j) % 13] += dp[i][ki]
for j in range(13):
dp[i + 1][j] %= MOD
print((dp[n][5]))
| false | 13.043478 | [
"+s = eval(input())",
"+n = len(s)",
"-S = eval(input())",
"-cur = [0] * 13",
"-cur[0] = 1",
"-r = 1",
"-base = 0",
"-for i in range(len(S)):",
"- s = S[-(i + 1)]",
"- if s == \"?\":",
"- prev = cur",
"- cur = [sum(prev)] * 13",
"- for m in range(13):",
"- for d in range(10, 13):",
"- cur[(m + r * d) % 13] -= prev[m]",
"- for m in range(13):",
"- cur[m] %= MOD",
"+dp = [[0] * 13 for _ in range(n + 1)]",
"+dp[0][0] = 1",
"+for i in range(n):",
"+ if s[i] == \"?\":",
"+ c = -1",
"- base = (base + r * int(s)) % 13",
"- r = (10 * r) % 13",
"-print((cur[(5 - base) % 13]))",
"+ c = int(s[i])",
"+ for j in range(10):",
"+ if c != -1 and c != j:",
"+ continue",
"+ for ki in range(13):",
"+ dp[i + 1][(ki * 10 + j) % 13] += dp[i][ki]",
"+ for j in range(13):",
"+ dp[i + 1][j] %= MOD",
"+print((dp[n][5]))"
] | false | 0.037048 | 0.037571 | 0.986097 | [
"s976079092",
"s865239971"
] |
u117193815 | p03161 | python | s514356411 | s556434214 | 463 | 419 | 55,264 | 55,136 | Accepted | Accepted | 9.5 | n, k= list(map(int, input().split()))
l = list(map(int, input().split()))
dp = [float("inf")]*n
dp[0] = 0
for i in range(n-1):
for j in range(1,min(k+1,(n-i))):
dp[i+j]=min(dp[i]+(abs(l[i]-l[i+j])),dp[i+j])
print((dp[-1])) | n, k = list(map(int, input().split()))
h = list(map(int, input().split()))
dp=[float("inf")]*n
dp[0]=0
for i in range(n-1):
for j in range(1,min(k+1,abs(n-i))):
dp[i+j]=min(dp[i+j],dp[i]+abs(h[i]-h[j+i]))
print((dp[-1])) | 8 | 8 | 233 | 231 | n, k = list(map(int, input().split()))
l = list(map(int, input().split()))
dp = [float("inf")] * n
dp[0] = 0
for i in range(n - 1):
for j in range(1, min(k + 1, (n - i))):
dp[i + j] = min(dp[i] + (abs(l[i] - l[i + j])), dp[i + j])
print((dp[-1]))
| n, k = list(map(int, input().split()))
h = list(map(int, input().split()))
dp = [float("inf")] * n
dp[0] = 0
for i in range(n - 1):
for j in range(1, min(k + 1, abs(n - i))):
dp[i + j] = min(dp[i + j], dp[i] + abs(h[i] - h[j + i]))
print((dp[-1]))
| false | 0 | [
"-l = list(map(int, input().split()))",
"+h = list(map(int, input().split()))",
"- for j in range(1, min(k + 1, (n - i))):",
"- dp[i + j] = min(dp[i] + (abs(l[i] - l[i + j])), dp[i + j])",
"+ for j in range(1, min(k + 1, abs(n - i))):",
"+ dp[i + j] = min(dp[i + j], dp[i] + abs(h[i] - h[j + i]))"
] | false | 0.110085 | 0.045784 | 2.404455 | [
"s514356411",
"s556434214"
] |
u912237403 | p00125 | python | s037166760 | s737070380 | 20 | 10 | 4,396 | 4,408 | Accepted | Accepted | 50 | import datetime as D
while 1:
a,b,c,d,e,f=x=list(map(int,input().split(" ")))
if min(x)<0: break
print((D.date(d,e,f)-D.date(a,b,c)).days) | import datetime as D
while 1:
a,b,c,d,e,f=x=list(map(int,input().split(" ")))
if any([i<0 for i in x]): break
print((D.date(d,e,f)-D.date(a,b,c)).days) | 5 | 5 | 145 | 161 | import datetime as D
while 1:
a, b, c, d, e, f = x = list(map(int, input().split(" ")))
if min(x) < 0:
break
print((D.date(d, e, f) - D.date(a, b, c)).days)
| import datetime as D
while 1:
a, b, c, d, e, f = x = list(map(int, input().split(" ")))
if any([i < 0 for i in x]):
break
print((D.date(d, e, f) - D.date(a, b, c)).days)
| false | 0 | [
"- if min(x) < 0:",
"+ if any([i < 0 for i in x]):"
] | false | 0.040775 | 0.040197 | 1.014393 | [
"s037166760",
"s737070380"
] |
u354638986 | p04013 | python | s136095584 | s711983619 | 1,799 | 142 | 65,520 | 5,740 | Accepted | Accepted | 92.11 | n, a = list(map(int, input().split()))
x = list(map(int, input().split()))
def ave_comb(v_max, ave):
dp = [[[0 for c in range(n*v_max+1)] for b in range(n+1)] for a in range(n+1)]
for i in range(n+1):
dp[i][0][0] = 1
for i in range(1, n+1):
for j in range(1, i+1):
for k in range(1, n*v_max+1):
if k - x[i-1] >= 0:
dp[i][j][k] = dp[i-1][j-1][k-x[i-1]] + dp[i-1][j][k]
else:
dp[i][j][k] = dp[i-1][j][k]
ans = 0
for t in range(1, n+1):
ans += dp[n][t][ave*t]
return ans
def main():
x_max = max(max(x), a)
print((ave_comb(x_max, a)))
if __name__ == '__main__':
main()
| n, a = list(map(int, input().split()))
x = list(map(int, input().split()))
x_max = max(x)
y = [i-a for i in x]
def ave_comb():
dp = [[0 for d in range(2*n*x_max+1)] for c in range(n+1)]
for i in range(n+1):
dp[i][n*x_max] = 1
for i in range(1, n+1):
for j in range(1, 2*n*x_max+1):
if 0 <= j - y[i-1] <= 2 * n * x_max:
dp[i][j] = dp[i-1][j-y[i-1]] + dp[i-1][j]
else:
dp[i][j] = dp[i-1][j]
return dp[n][n*x_max] - 1
def main():
print((ave_comb()))
if __name__ == '__main__':
main()
| 33 | 28 | 744 | 605 | n, a = list(map(int, input().split()))
x = list(map(int, input().split()))
def ave_comb(v_max, ave):
dp = [
[[0 for c in range(n * v_max + 1)] for b in range(n + 1)] for a in range(n + 1)
]
for i in range(n + 1):
dp[i][0][0] = 1
for i in range(1, n + 1):
for j in range(1, i + 1):
for k in range(1, n * v_max + 1):
if k - x[i - 1] >= 0:
dp[i][j][k] = dp[i - 1][j - 1][k - x[i - 1]] + dp[i - 1][j][k]
else:
dp[i][j][k] = dp[i - 1][j][k]
ans = 0
for t in range(1, n + 1):
ans += dp[n][t][ave * t]
return ans
def main():
x_max = max(max(x), a)
print((ave_comb(x_max, a)))
if __name__ == "__main__":
main()
| n, a = list(map(int, input().split()))
x = list(map(int, input().split()))
x_max = max(x)
y = [i - a for i in x]
def ave_comb():
dp = [[0 for d in range(2 * n * x_max + 1)] for c in range(n + 1)]
for i in range(n + 1):
dp[i][n * x_max] = 1
for i in range(1, n + 1):
for j in range(1, 2 * n * x_max + 1):
if 0 <= j - y[i - 1] <= 2 * n * x_max:
dp[i][j] = dp[i - 1][j - y[i - 1]] + dp[i - 1][j]
else:
dp[i][j] = dp[i - 1][j]
return dp[n][n * x_max] - 1
def main():
print((ave_comb()))
if __name__ == "__main__":
main()
| false | 15.151515 | [
"+x_max = max(x)",
"+y = [i - a for i in x]",
"-def ave_comb(v_max, ave):",
"- dp = [",
"- [[0 for c in range(n * v_max + 1)] for b in range(n + 1)] for a in range(n + 1)",
"- ]",
"+def ave_comb():",
"+ dp = [[0 for d in range(2 * n * x_max + 1)] for c in range(n + 1)]",
"- dp[i][0][0] = 1",
"+ dp[i][n * x_max] = 1",
"- for j in range(1, i + 1):",
"- for k in range(1, n * v_max + 1):",
"- if k - x[i - 1] >= 0:",
"- dp[i][j][k] = dp[i - 1][j - 1][k - x[i - 1]] + dp[i - 1][j][k]",
"- else:",
"- dp[i][j][k] = dp[i - 1][j][k]",
"- ans = 0",
"- for t in range(1, n + 1):",
"- ans += dp[n][t][ave * t]",
"- return ans",
"+ for j in range(1, 2 * n * x_max + 1):",
"+ if 0 <= j - y[i - 1] <= 2 * n * x_max:",
"+ dp[i][j] = dp[i - 1][j - y[i - 1]] + dp[i - 1][j]",
"+ else:",
"+ dp[i][j] = dp[i - 1][j]",
"+ return dp[n][n * x_max] - 1",
"- x_max = max(max(x), a)",
"- print((ave_comb(x_max, a)))",
"+ print((ave_comb()))"
] | false | 0.079411 | 0.0415 | 1.913516 | [
"s136095584",
"s711983619"
] |
u529012223 | p02923 | python | s762072657 | s643355012 | 79 | 65 | 14,252 | 14,224 | Accepted | Accepted | 17.72 | #139
N = int(eval(input()))
H = list(map(int, input().split()))
count = 0
count_new = 0
flag = 0
for i in range(N-1):
if H[i] >= H[i + 1]:
# print("i", i)
count_new += 1
# print(count)
if i == N - 2 and flag == 0:
flag = 1
count = count_new
# print(count, "k")
elif i == N - 2 and count_new > count:
count = count_new
# print(count)
else:
flag = 1
if count_new > count:
count = count_new
count_new = 0
print(count) | N = int(eval(input()))
H = list(map(int, input().split()))
count = 0
c_max = 0
for i in range(N-1):
if H[i] >= H[i+1]:
count += 1
else:
if c_max < count:
c_max = count
count = 0
print((max(c_max, count))) | 27 | 14 | 582 | 255 | # 139
N = int(eval(input()))
H = list(map(int, input().split()))
count = 0
count_new = 0
flag = 0
for i in range(N - 1):
if H[i] >= H[i + 1]:
# print("i", i)
count_new += 1
# print(count)
if i == N - 2 and flag == 0:
flag = 1
count = count_new
# print(count, "k")
elif i == N - 2 and count_new > count:
count = count_new
# print(count)
else:
flag = 1
if count_new > count:
count = count_new
count_new = 0
print(count)
| N = int(eval(input()))
H = list(map(int, input().split()))
count = 0
c_max = 0
for i in range(N - 1):
if H[i] >= H[i + 1]:
count += 1
else:
if c_max < count:
c_max = count
count = 0
print((max(c_max, count)))
| false | 48.148148 | [
"-# 139",
"-count_new = 0",
"-flag = 0",
"+c_max = 0",
"- # print(\"i\", i)",
"- count_new += 1",
"- # print(count)",
"- if i == N - 2 and flag == 0:",
"- flag = 1",
"- count = count_new",
"- # print(count, \"k\")",
"- elif i == N - 2 and count_new > count:",
"- count = count_new",
"- # print(count)",
"+ count += 1",
"- flag = 1",
"- if count_new > count:",
"- count = count_new",
"- count_new = 0",
"-print(count)",
"+ if c_max < count:",
"+ c_max = count",
"+ count = 0",
"+print((max(c_max, count)))"
] | false | 0.042969 | 0.041474 | 1.036032 | [
"s762072657",
"s643355012"
] |
u693716675 | p02683 | python | s011907747 | s697513495 | 173 | 95 | 27,168 | 9,220 | Accepted | Accepted | 45.09 | import numpy as np
n,m,x = [int(i) for i in input().split()]
costs =[]
maa = 1000000000000000000000000000
ans = maa
for i in range(n):
a = [int(i) for i in input().split()]
costs.append(a)
for i in range(1,2**n+1):
cost = 0
c = 0
sums = [0] * m
use_index=[]
for j in range(n):
if i%2==1:
use_index.append(j)
i >>= 1
for v in use_index:
c += costs[v][0]
for j in range(m):
sums[j] += costs[v][j+1]
judge=True
for j in range(m):
if sums[j]<x:
judge=False
break
if judge:
ans = min(ans, c)
if ans ==maa:
print((-1))
else:
print(ans)
| n,m,x = list(map(int, input().split()))
costs = [list(map(int, input().split())) for _ in range(n)]
'''
n,m,x = [int(i) for i in input().split()]
costs =[]
for i in range(n):
a = [int(i) for i in input().split()]
costs.append(a)
'''
INF = 1000000000000000000000000000
ans = INF
for i in range(1<<n): #n bits all searches
# 1<<n == 2**n
c = 0
sums = [0]*m
for j in range(n):
if i>>j & 1: #i>>j %2 == 1 is also fine.
#apply this candidate.
c += costs[j][0]
for k in range(m):
sums[k] += costs[j][k+1]
'''
cost = 0
c = 0
sums = [0] * m
use_index=[]
for j in range(n):
if i%2==1:
use_index.append(j)
i >>= 1
for v in use_index:
c += costs[v][0]
for j in range(m):
sums[j] += costs[v][j+1]
'''
if min(sums) >= x:
ans = min(ans, c)
'''
judge=True
for j in range(m):
if sums[j]<x:
judge=False
break
if judge:
ans = min(ans, c)
'''
if ans==INF:
print((-1))
else:
print(ans)
| 44 | 59 | 794 | 1,208 | import numpy as np
n, m, x = [int(i) for i in input().split()]
costs = []
maa = 1000000000000000000000000000
ans = maa
for i in range(n):
a = [int(i) for i in input().split()]
costs.append(a)
for i in range(1, 2**n + 1):
cost = 0
c = 0
sums = [0] * m
use_index = []
for j in range(n):
if i % 2 == 1:
use_index.append(j)
i >>= 1
for v in use_index:
c += costs[v][0]
for j in range(m):
sums[j] += costs[v][j + 1]
judge = True
for j in range(m):
if sums[j] < x:
judge = False
break
if judge:
ans = min(ans, c)
if ans == maa:
print((-1))
else:
print(ans)
| n, m, x = list(map(int, input().split()))
costs = [list(map(int, input().split())) for _ in range(n)]
"""
n,m,x = [int(i) for i in input().split()]
costs =[]
for i in range(n):
a = [int(i) for i in input().split()]
costs.append(a)
"""
INF = 1000000000000000000000000000
ans = INF
for i in range(1 << n): # n bits all searches
# 1<<n == 2**n
c = 0
sums = [0] * m
for j in range(n):
if i >> j & 1: # i>>j %2 == 1 is also fine.
# apply this candidate.
c += costs[j][0]
for k in range(m):
sums[k] += costs[j][k + 1]
"""
cost = 0
c = 0
sums = [0] * m
use_index=[]
for j in range(n):
if i%2==1:
use_index.append(j)
i >>= 1
for v in use_index:
c += costs[v][0]
for j in range(m):
sums[j] += costs[v][j+1]
"""
if min(sums) >= x:
ans = min(ans, c)
"""
judge=True
for j in range(m):
if sums[j]<x:
judge=False
break
if judge:
ans = min(ans, c)
"""
if ans == INF:
print((-1))
else:
print(ans)
| false | 25.423729 | [
"-import numpy as np",
"-",
"-n, m, x = [int(i) for i in input().split()]",
"-costs = []",
"-maa = 1000000000000000000000000000",
"-ans = maa",
"+n, m, x = list(map(int, input().split()))",
"+costs = [list(map(int, input().split())) for _ in range(n)]",
"+\"\"\"",
"+n,m,x = [int(i) for i in input().split()]",
"+costs =[]",
"-for i in range(1, 2**n + 1):",
"+\"\"\"",
"+INF = 1000000000000000000000000000",
"+ans = INF",
"+for i in range(1 << n): # n bits all searches",
"+ # 1<<n == 2**n",
"+ c = 0",
"+ sums = [0] * m",
"+ for j in range(n):",
"+ if i >> j & 1: # i>>j %2 == 1 is also fine.",
"+ # apply this candidate.",
"+ c += costs[j][0]",
"+ for k in range(m):",
"+ sums[k] += costs[j][k + 1]",
"+ \"\"\"",
"- use_index = []",
"+ use_index=[]",
"- if i % 2 == 1:",
"+ if i%2==1:",
"- c += costs[v][0]",
"+ c += costs[v][0]",
"- sums[j] += costs[v][j + 1]",
"- judge = True",
"+ sums[j] += costs[v][j+1]",
"+ \"\"\"",
"+ if min(sums) >= x:",
"+ ans = min(ans, c)",
"+\"\"\"",
"+ judge=True",
"- if sums[j] < x:",
"- judge = False",
"+ if sums[j]<x:",
"+ judge=False",
"-if ans == maa:",
"+\"\"\"",
"+if ans == INF:"
] | false | 0.040266 | 0.044119 | 0.912647 | [
"s011907747",
"s697513495"
] |
u116002573 | p02982 | python | s909583178 | s393364938 | 166 | 18 | 38,384 | 3,064 | Accepted | Accepted | 89.16 | import math
def main():
x = []
N, D = list(map(int, input().split()))
for _ in range(N):
y = list(map(int, input().split()))
x.append(y)
ans = 0
for i in range(N):
for j in range(i):
d1 = 0
for k in range(D):
d1 += pow(x[i][k]-x[j][k], 2)
d1 = math.sqrt(d1)
if d1 == int(d1): ans += 1
return ans
if __name__ == '__main__':
print((main())) | import math
def main():
N, D = list(map(int, input().split()))
pt = []
for _ in range(N):
p = list(map(int, input().split()))
pt.append(p)
ans = 0
for i in range(N):
for j in range(i):
l = 0
for k in range(D):
l += pow(pt[i][k]-pt[j][k], 2)
l = math.sqrt(l)
if l == int(l): ans += 1
return ans
if __name__ == '__main__':
print((main()))
| 20 | 20 | 467 | 466 | import math
def main():
x = []
N, D = list(map(int, input().split()))
for _ in range(N):
y = list(map(int, input().split()))
x.append(y)
ans = 0
for i in range(N):
for j in range(i):
d1 = 0
for k in range(D):
d1 += pow(x[i][k] - x[j][k], 2)
d1 = math.sqrt(d1)
if d1 == int(d1):
ans += 1
return ans
if __name__ == "__main__":
print((main()))
| import math
def main():
N, D = list(map(int, input().split()))
pt = []
for _ in range(N):
p = list(map(int, input().split()))
pt.append(p)
ans = 0
for i in range(N):
for j in range(i):
l = 0
for k in range(D):
l += pow(pt[i][k] - pt[j][k], 2)
l = math.sqrt(l)
if l == int(l):
ans += 1
return ans
if __name__ == "__main__":
print((main()))
| false | 0 | [
"- x = []",
"+ pt = []",
"- y = list(map(int, input().split()))",
"- x.append(y)",
"+ p = list(map(int, input().split()))",
"+ pt.append(p)",
"- d1 = 0",
"+ l = 0",
"- d1 += pow(x[i][k] - x[j][k], 2)",
"- d1 = math.sqrt(d1)",
"- if d1 == int(d1):",
"+ l += pow(pt[i][k] - pt[j][k], 2)",
"+ l = math.sqrt(l)",
"+ if l == int(l):"
] | false | 0.047631 | 0.033614 | 1.417005 | [
"s909583178",
"s393364938"
] |
u763881112 | p03386 | python | s496019975 | s013186102 | 19 | 17 | 3,060 | 3,060 | Accepted | Accepted | 10.53 | a,b,k=map(int,input().split())
se=set(set(range(a,a+k))|set(range(b-k+1,b+1)))
li=[x for x in se if a<=x<=b]
li=sorted(li)
print(*li,sep="\n")
| a,b,k=list(map(int,input().split()))
s=set()
for i in range(k):
if(a+i<=b):s.add(a+i)
if(b-i>=a):s.add(b-i)
s=sorted(s)
for x in s:
print(x) | 5 | 8 | 147 | 153 | a, b, k = map(int, input().split())
se = set(set(range(a, a + k)) | set(range(b - k + 1, b + 1)))
li = [x for x in se if a <= x <= b]
li = sorted(li)
print(*li, sep="\n")
| a, b, k = list(map(int, input().split()))
s = set()
for i in range(k):
if a + i <= b:
s.add(a + i)
if b - i >= a:
s.add(b - i)
s = sorted(s)
for x in s:
print(x)
| false | 37.5 | [
"-a, b, k = map(int, input().split())",
"-se = set(set(range(a, a + k)) | set(range(b - k + 1, b + 1)))",
"-li = [x for x in se if a <= x <= b]",
"-li = sorted(li)",
"-print(*li, sep=\"\\n\")",
"+a, b, k = list(map(int, input().split()))",
"+s = set()",
"+for i in range(k):",
"+ if a + i <= b:",
"+ s.add(a + i)",
"+ if b - i >= a:",
"+ s.add(b - i)",
"+s = sorted(s)",
"+for x in s:",
"+ print(x)"
] | false | 0.042787 | 0.042911 | 0.99711 | [
"s496019975",
"s013186102"
] |
u816116805 | p02873 | python | s812430626 | s890289024 | 361 | 318 | 21,512 | 35,632 | Accepted | Accepted | 11.91 | #! /usr/bin/env python
# -*- coding: utf-8 -*-
# vim:fenc=utf-8
#
"""
GC040 A
"""
ali = list(eval(input()))
zeroflag = False
lastflag = False
if ali[0] == '<':
ali.insert(0, '>')
zeroflag = True
if ali[-1] == '>':
ali.append('<')
lastflag = True
itop = []
ibtm = []
# print(ali)
for (i, x) in enumerate(ali[:-1]):
# print(i)
if x == '>' and ali[i+1] == '<':
ibtm.append(i+1)
if x == '<' and ali[i+1] == '>':
itop.append(i+1)
itop.append(len(ali))
# print(itop)
# print(ibtm)
s = 0
nowtop = 0
toplheight = [-10]
toprheight = []
for l in range(len(itop)):
nexttop = itop[l]
nowbtm = ibtm[l]
lint = nowbtm - nowtop - 1
rint = nexttop - nowbtm - 1
s += (lint)*(lint+1)//2
s += (rint)*(rint+1)//2
toprheight.append(lint)
toplheight.append(rint)
# print('l',l)
# print('s',s)
nowtop = nexttop
toprheight.append(-10)
if zeroflag:
del toplheight[0]
del toprheight[0]
if lastflag:
toplheight.pop()
toprheight.pop()
while toplheight:
left = toplheight.pop()
right = toprheight.pop()
s += max(left, right)+1
print(s)
| #! /usr/bin/env python
# -*- coding: utf-8 -*-
# vim:fenc=utf-8
#
"""
GC040 A-2
"""
ali = list(eval(input()))
tmp = 0
b = [0]
for L in ali:
if L == '<':
tmp += 1
else:
tmp = 0
b.append(tmp)
tmp = 0
c = [0]
ali.reverse()
for L in ali:
if L == '>':
tmp += 1
else:
tmp = 0
c.append(tmp)
c.reverse()
numlist = [max(a, b) for (a, b) in zip(b, c)]
print((sum(numlist)))
| 70 | 33 | 1,199 | 449 | #! /usr/bin/env python
# -*- coding: utf-8 -*-
# vim:fenc=utf-8
#
"""
GC040 A
"""
ali = list(eval(input()))
zeroflag = False
lastflag = False
if ali[0] == "<":
ali.insert(0, ">")
zeroflag = True
if ali[-1] == ">":
ali.append("<")
lastflag = True
itop = []
ibtm = []
# print(ali)
for (i, x) in enumerate(ali[:-1]):
# print(i)
if x == ">" and ali[i + 1] == "<":
ibtm.append(i + 1)
if x == "<" and ali[i + 1] == ">":
itop.append(i + 1)
itop.append(len(ali))
# print(itop)
# print(ibtm)
s = 0
nowtop = 0
toplheight = [-10]
toprheight = []
for l in range(len(itop)):
nexttop = itop[l]
nowbtm = ibtm[l]
lint = nowbtm - nowtop - 1
rint = nexttop - nowbtm - 1
s += (lint) * (lint + 1) // 2
s += (rint) * (rint + 1) // 2
toprheight.append(lint)
toplheight.append(rint)
# print('l',l)
# print('s',s)
nowtop = nexttop
toprheight.append(-10)
if zeroflag:
del toplheight[0]
del toprheight[0]
if lastflag:
toplheight.pop()
toprheight.pop()
while toplheight:
left = toplheight.pop()
right = toprheight.pop()
s += max(left, right) + 1
print(s)
| #! /usr/bin/env python
# -*- coding: utf-8 -*-
# vim:fenc=utf-8
#
"""
GC040 A-2
"""
ali = list(eval(input()))
tmp = 0
b = [0]
for L in ali:
if L == "<":
tmp += 1
else:
tmp = 0
b.append(tmp)
tmp = 0
c = [0]
ali.reverse()
for L in ali:
if L == ">":
tmp += 1
else:
tmp = 0
c.append(tmp)
c.reverse()
numlist = [max(a, b) for (a, b) in zip(b, c)]
print((sum(numlist)))
| false | 52.857143 | [
"-GC040 A",
"+GC040 A-2",
"-zeroflag = False",
"-lastflag = False",
"-if ali[0] == \"<\":",
"- ali.insert(0, \">\")",
"- zeroflag = True",
"-if ali[-1] == \">\":",
"- ali.append(\"<\")",
"- lastflag = True",
"-itop = []",
"-ibtm = []",
"-# print(ali)",
"-for (i, x) in enumerate(ali[:-1]):",
"- # print(i)",
"- if x == \">\" and ali[i + 1] == \"<\":",
"- ibtm.append(i + 1)",
"- if x == \"<\" and ali[i + 1] == \">\":",
"- itop.append(i + 1)",
"-itop.append(len(ali))",
"-# print(itop)",
"-# print(ibtm)",
"-s = 0",
"-nowtop = 0",
"-toplheight = [-10]",
"-toprheight = []",
"-for l in range(len(itop)):",
"- nexttop = itop[l]",
"- nowbtm = ibtm[l]",
"- lint = nowbtm - nowtop - 1",
"- rint = nexttop - nowbtm - 1",
"- s += (lint) * (lint + 1) // 2",
"- s += (rint) * (rint + 1) // 2",
"- toprheight.append(lint)",
"- toplheight.append(rint)",
"- # print('l',l)",
"- # print('s',s)",
"- nowtop = nexttop",
"-toprheight.append(-10)",
"-if zeroflag:",
"- del toplheight[0]",
"- del toprheight[0]",
"-if lastflag:",
"- toplheight.pop()",
"- toprheight.pop()",
"-while toplheight:",
"- left = toplheight.pop()",
"- right = toprheight.pop()",
"- s += max(left, right) + 1",
"-print(s)",
"+tmp = 0",
"+b = [0]",
"+for L in ali:",
"+ if L == \"<\":",
"+ tmp += 1",
"+ else:",
"+ tmp = 0",
"+ b.append(tmp)",
"+tmp = 0",
"+c = [0]",
"+ali.reverse()",
"+for L in ali:",
"+ if L == \">\":",
"+ tmp += 1",
"+ else:",
"+ tmp = 0",
"+ c.append(tmp)",
"+c.reverse()",
"+numlist = [max(a, b) for (a, b) in zip(b, c)]",
"+print((sum(numlist)))"
] | false | 0.106149 | 0.044834 | 2.367612 | [
"s812430626",
"s890289024"
] |
u379692329 | p03161 | python | s092349340 | s306890662 | 1,893 | 480 | 14,104 | 55,392 | Accepted | Accepted | 74.64 | import sys
input = sys.stdin.readline
N, K = list(map(int, input().split()))
h = [int(x) for x in input().split()]
dp = [0] * N
for i, hi in enumerate(h):
if i == 0:
continue
if i - K < 0:
dp[i] = min(dpk + abs(hi-hk) for dpk, hk in zip(dp[:i], h[:i]))
else:
dp[i] = min(dpk + abs(hi-hk) for dpk, hk in zip(dp[i-K:i], h[i-K:i]))
print((dp[-1])) | N, K = list(map(int, input().split()))
h = [int(_) for _ in input().split()]
dp = [float('inf')]*(N)
dp[0] = 0
dp[1] = abs(h[1]-h[0])
for i in range(2, N):
for j in range(1, K+1):
if i >= j:
dp[i] = min(dp[i-j]+abs(h[i]-h[i-j]), dp[i])
print((dp[N-1])) | 16 | 12 | 390 | 281 | import sys
input = sys.stdin.readline
N, K = list(map(int, input().split()))
h = [int(x) for x in input().split()]
dp = [0] * N
for i, hi in enumerate(h):
if i == 0:
continue
if i - K < 0:
dp[i] = min(dpk + abs(hi - hk) for dpk, hk in zip(dp[:i], h[:i]))
else:
dp[i] = min(dpk + abs(hi - hk) for dpk, hk in zip(dp[i - K : i], h[i - K : i]))
print((dp[-1]))
| N, K = list(map(int, input().split()))
h = [int(_) for _ in input().split()]
dp = [float("inf")] * (N)
dp[0] = 0
dp[1] = abs(h[1] - h[0])
for i in range(2, N):
for j in range(1, K + 1):
if i >= j:
dp[i] = min(dp[i - j] + abs(h[i] - h[i - j]), dp[i])
print((dp[N - 1]))
| false | 25 | [
"-import sys",
"-",
"-input = sys.stdin.readline",
"-h = [int(x) for x in input().split()]",
"-dp = [0] * N",
"-for i, hi in enumerate(h):",
"- if i == 0:",
"- continue",
"- if i - K < 0:",
"- dp[i] = min(dpk + abs(hi - hk) for dpk, hk in zip(dp[:i], h[:i]))",
"- else:",
"- dp[i] = min(dpk + abs(hi - hk) for dpk, hk in zip(dp[i - K : i], h[i - K : i]))",
"-print((dp[-1]))",
"+h = [int(_) for _ in input().split()]",
"+dp = [float(\"inf\")] * (N)",
"+dp[0] = 0",
"+dp[1] = abs(h[1] - h[0])",
"+for i in range(2, N):",
"+ for j in range(1, K + 1):",
"+ if i >= j:",
"+ dp[i] = min(dp[i - j] + abs(h[i] - h[i - j]), dp[i])",
"+print((dp[N - 1]))"
] | false | 0.130973 | 0.046431 | 2.820833 | [
"s092349340",
"s306890662"
] |
u794173881 | p02881 | python | s202493970 | s356724057 | 194 | 122 | 39,792 | 3,280 | Accepted | Accepted | 37.11 | def make_divisors(n):
"""自然数nの約数を列挙したリストを出力する
計算量: O(sqrt(N))
入出力例: 12 -> [1, 2, 3, 4, 6, 12]
"""
divisors = []
for k in range(1, int(n**0.5) + 1):
if n % k == 0:
divisors.append(k)
if k != n // k:
divisors.append(n // k)
divisors = sorted(divisors)
return divisors
n = int(eval(input()))
ans = make_divisors(n)
res = 10**18
for i in range(len(ans)):
tmp = ans[i] + n // ans[i] - 2
res = min(tmp, res)
print(res) | def make_divisors(n: int) -> list:
"""自然数nの約数を列挙したリストを出力する
計算量: O(sqrt(N))
入出力例: 12 -> [1, 2, 3, 4, 6, 12]
"""
divisors = []
for k in range(1, int(n ** 0.5) + 1):
if n % k == 0:
divisors.append(k)
if k != n // k:
divisors.append(n // k)
divisors = sorted(divisors)
return divisors
n = int(eval(input()))
div = make_divisors(n)
ans = 10 ** 18
for i in div:
ans = min(ans, i + n // i - 2)
print(ans) | 22 | 21 | 517 | 497 | def make_divisors(n):
"""自然数nの約数を列挙したリストを出力する
計算量: O(sqrt(N))
入出力例: 12 -> [1, 2, 3, 4, 6, 12]
"""
divisors = []
for k in range(1, int(n**0.5) + 1):
if n % k == 0:
divisors.append(k)
if k != n // k:
divisors.append(n // k)
divisors = sorted(divisors)
return divisors
n = int(eval(input()))
ans = make_divisors(n)
res = 10**18
for i in range(len(ans)):
tmp = ans[i] + n // ans[i] - 2
res = min(tmp, res)
print(res)
| def make_divisors(n: int) -> list:
"""自然数nの約数を列挙したリストを出力する
計算量: O(sqrt(N))
入出力例: 12 -> [1, 2, 3, 4, 6, 12]
"""
divisors = []
for k in range(1, int(n**0.5) + 1):
if n % k == 0:
divisors.append(k)
if k != n // k:
divisors.append(n // k)
divisors = sorted(divisors)
return divisors
n = int(eval(input()))
div = make_divisors(n)
ans = 10**18
for i in div:
ans = min(ans, i + n // i - 2)
print(ans)
| false | 4.545455 | [
"-def make_divisors(n):",
"+def make_divisors(n: int) -> list:",
"-ans = make_divisors(n)",
"-res = 10**18",
"-for i in range(len(ans)):",
"- tmp = ans[i] + n // ans[i] - 2",
"- res = min(tmp, res)",
"-print(res)",
"+div = make_divisors(n)",
"+ans = 10**18",
"+for i in div:",
"+ ans = min(ans, i + n // i - 2)",
"+print(ans)"
] | false | 0.082861 | 0.059879 | 1.383817 | [
"s202493970",
"s356724057"
] |
u776758454 | p02389 | python | s051677383 | s794803513 | 30 | 20 | 7,696 | 7,764 | Accepted | Accepted | 33.33 | def main():
input_string = eval(input(''))
elements = input_string.split(' ')
height_a = int(elements[0])
width_b = int(elements[1])
print(('%d %d' % ((height_a * width_b), (2 * height_a + 2 * width_b))))
main() | def main():
[height_a, width_b] = list(map(int, input().split()))
print(('%d %d' % ((height_a * width_b), (2 * height_a + 2 * width_b))))
main() | 8 | 7 | 231 | 159 | def main():
input_string = eval(input(""))
elements = input_string.split(" ")
height_a = int(elements[0])
width_b = int(elements[1])
print(("%d %d" % ((height_a * width_b), (2 * height_a + 2 * width_b))))
main()
| def main():
[height_a, width_b] = list(map(int, input().split()))
print(("%d %d" % ((height_a * width_b), (2 * height_a + 2 * width_b))))
main()
| false | 12.5 | [
"- input_string = eval(input(\"\"))",
"- elements = input_string.split(\" \")",
"- height_a = int(elements[0])",
"- width_b = int(elements[1])",
"+ [height_a, width_b] = list(map(int, input().split()))"
] | false | 0.077299 | 0.0678 | 1.140105 | [
"s051677383",
"s794803513"
] |
u078349616 | p02866 | python | s283676835 | s741700483 | 160 | 147 | 14,396 | 13,892 | Accepted | Accepted | 8.12 | N = int(eval(input()))
D = list(map(int, input().split()))
mod = 998244353
ans = 1
A = [0]*(max(D)+1)
for i in range(N):
A[D[i]] += 1
#if D[0] != 0 or not all(D[1:]) or not all(A):
# print(0)
# exit()
if D[0] != 0 or not all(D[1:]):
print((0))
exit()
for i in range(1, max(D)+1):
# print(A[i])
if A[i] == 0:
print((0))
exit()
ans = ans * pow(A[i-1], A[i], mod) % mod
print((ans % mod)) | N = int(eval(input()))
D = list(map(int, input().split()))
mod = 998244353
ans = 1
A = [0]*(max(D)+1)
for i in range(N):
A[D[i]] += 1
if D[0] != 0 or not all(D[1:]) or not all(A):
print((0))
exit()
for i in range(1, max(D)+1):
ans = ans * pow(A[i-1], A[i], mod) % mod
print((ans % mod)) | 20 | 13 | 413 | 296 | N = int(eval(input()))
D = list(map(int, input().split()))
mod = 998244353
ans = 1
A = [0] * (max(D) + 1)
for i in range(N):
A[D[i]] += 1
# if D[0] != 0 or not all(D[1:]) or not all(A):
# print(0)
# exit()
if D[0] != 0 or not all(D[1:]):
print((0))
exit()
for i in range(1, max(D) + 1):
# print(A[i])
if A[i] == 0:
print((0))
exit()
ans = ans * pow(A[i - 1], A[i], mod) % mod
print((ans % mod))
| N = int(eval(input()))
D = list(map(int, input().split()))
mod = 998244353
ans = 1
A = [0] * (max(D) + 1)
for i in range(N):
A[D[i]] += 1
if D[0] != 0 or not all(D[1:]) or not all(A):
print((0))
exit()
for i in range(1, max(D) + 1):
ans = ans * pow(A[i - 1], A[i], mod) % mod
print((ans % mod))
| false | 35 | [
"-# if D[0] != 0 or not all(D[1:]) or not all(A):",
"-# print(0)",
"-# exit()",
"-if D[0] != 0 or not all(D[1:]):",
"+if D[0] != 0 or not all(D[1:]) or not all(A):",
"- # print(A[i])",
"- if A[i] == 0:",
"- print((0))",
"- exit()"
] | false | 0.041224 | 0.045186 | 0.912322 | [
"s283676835",
"s741700483"
] |
u748241164 | p03262 | python | s837572757 | s776336578 | 340 | 246 | 88,852 | 63,640 | Accepted | Accepted | 27.65 | import fractions
from functools import reduce
N, X = list(map(int, input().split()))
listx = list(map(int, input().split()))
subx = []
for i in range(N):
subx.append(abs(listx[i] - X))
def lcm_list(numbers):
return reduce(fractions.gcd, numbers)
ans = lcm_list(subx)
print(ans) | N, X = list(map(int, input().split()))
listx = list(map(int, input().split()))
subx = []
for i in range(N):
subx.append(abs(listx[i] - X))
if N == 1:
subx.append(subx[0])
def gcd(a,b):
if a < b:
a, b = b, a
while a % b != 0:
a, b = b, a % b
return b
ans = gcd(subx[0], subx[1])
if N > 2:
for i in range(2, N):
ans = gcd(ans, subx[i])
print(ans) | 14 | 23 | 295 | 391 | import fractions
from functools import reduce
N, X = list(map(int, input().split()))
listx = list(map(int, input().split()))
subx = []
for i in range(N):
subx.append(abs(listx[i] - X))
def lcm_list(numbers):
return reduce(fractions.gcd, numbers)
ans = lcm_list(subx)
print(ans)
| N, X = list(map(int, input().split()))
listx = list(map(int, input().split()))
subx = []
for i in range(N):
subx.append(abs(listx[i] - X))
if N == 1:
subx.append(subx[0])
def gcd(a, b):
if a < b:
a, b = b, a
while a % b != 0:
a, b = b, a % b
return b
ans = gcd(subx[0], subx[1])
if N > 2:
for i in range(2, N):
ans = gcd(ans, subx[i])
print(ans)
| false | 39.130435 | [
"-import fractions",
"-from functools import reduce",
"-",
"+if N == 1:",
"+ subx.append(subx[0])",
"-def lcm_list(numbers):",
"- return reduce(fractions.gcd, numbers)",
"+def gcd(a, b):",
"+ if a < b:",
"+ a, b = b, a",
"+ while a % b != 0:",
"+ a, b = b, a % b",
"+ return b",
"-ans = lcm_list(subx)",
"+ans = gcd(subx[0], subx[1])",
"+if N > 2:",
"+ for i in range(2, N):",
"+ ans = gcd(ans, subx[i])"
] | false | 0.045399 | 0.036449 | 1.245564 | [
"s837572757",
"s776336578"
] |
u347640436 | p02862 | python | s854168663 | s145260535 | 281 | 196 | 29,300 | 31,052 | Accepted | Accepted | 30.25 | from sys import exit
def mpow(x, n):
result = 1
while n != 0:
if n & 1 == 1:
result *= x
result %= 1000000007
x *= x
x %= 1000000007
n >>= 1
return result
p = 1000000007
X, Y = list(map(int, input().split()))
if (X+Y) % 3 != 0:
print((0))
exit()
a = (2 * Y - X) // 3
b = (2 * X - Y) // 3
if a < 0 or b < 0:
print((0))
exit()
n = a + b
k = min(a, b)
if n == 0 and k == 0:
print((1))
exit()
if n < k or k < 0:
print((0))
exit()
fac = [0] * (n + 1)
fac[0] = 1
for i in range(n):
fac[i + 1] = fac[i] * (i + 1) % p
print((fac[n] * mpow(fac[n - k], p - 2) * mpow(fac[k], p - 2) % p))
| from sys import exit
def mpow(x, n):
result = 1
while n != 0:
if n & 1 == 1:
result *= x
result %= 1000000007
x *= x
x %= 1000000007
n >>= 1
return result
def mcomb(n, k):
if n == 0 and k == 0:
return 1
if n < k or k < 0:
return 0
fac = [0] * (n + 1)
fac[0] = 1
for i in range(n):
fac[i + 1] = fac[i] * (i + 1) % p
return fac[n] * mpow(fac[n - k], p - 2) * mpow(fac[k], p - 2) % p
p = 1000000007
X, Y = list(map(int, input().split()))
if (X+Y) % 3 != 0:
print((0))
exit()
a = (2 * Y - X) // 3
b = (2 * X - Y) // 3
if a < 0 or b < 0:
print((0))
exit()
print((mcomb(a + b, min(a, b))))
| 46 | 44 | 723 | 759 | from sys import exit
def mpow(x, n):
result = 1
while n != 0:
if n & 1 == 1:
result *= x
result %= 1000000007
x *= x
x %= 1000000007
n >>= 1
return result
p = 1000000007
X, Y = list(map(int, input().split()))
if (X + Y) % 3 != 0:
print((0))
exit()
a = (2 * Y - X) // 3
b = (2 * X - Y) // 3
if a < 0 or b < 0:
print((0))
exit()
n = a + b
k = min(a, b)
if n == 0 and k == 0:
print((1))
exit()
if n < k or k < 0:
print((0))
exit()
fac = [0] * (n + 1)
fac[0] = 1
for i in range(n):
fac[i + 1] = fac[i] * (i + 1) % p
print((fac[n] * mpow(fac[n - k], p - 2) * mpow(fac[k], p - 2) % p))
| from sys import exit
def mpow(x, n):
result = 1
while n != 0:
if n & 1 == 1:
result *= x
result %= 1000000007
x *= x
x %= 1000000007
n >>= 1
return result
def mcomb(n, k):
if n == 0 and k == 0:
return 1
if n < k or k < 0:
return 0
fac = [0] * (n + 1)
fac[0] = 1
for i in range(n):
fac[i + 1] = fac[i] * (i + 1) % p
return fac[n] * mpow(fac[n - k], p - 2) * mpow(fac[k], p - 2) % p
p = 1000000007
X, Y = list(map(int, input().split()))
if (X + Y) % 3 != 0:
print((0))
exit()
a = (2 * Y - X) // 3
b = (2 * X - Y) // 3
if a < 0 or b < 0:
print((0))
exit()
print((mcomb(a + b, min(a, b))))
| false | 4.347826 | [
"+def mcomb(n, k):",
"+ if n == 0 and k == 0:",
"+ return 1",
"+ if n < k or k < 0:",
"+ return 0",
"+ fac = [0] * (n + 1)",
"+ fac[0] = 1",
"+ for i in range(n):",
"+ fac[i + 1] = fac[i] * (i + 1) % p",
"+ return fac[n] * mpow(fac[n - k], p - 2) * mpow(fac[k], p - 2) % p",
"+",
"+",
"-n = a + b",
"-k = min(a, b)",
"-if n == 0 and k == 0:",
"- print((1))",
"- exit()",
"-if n < k or k < 0:",
"- print((0))",
"- exit()",
"-fac = [0] * (n + 1)",
"-fac[0] = 1",
"-for i in range(n):",
"- fac[i + 1] = fac[i] * (i + 1) % p",
"-print((fac[n] * mpow(fac[n - k], p - 2) * mpow(fac[k], p - 2) % p))",
"+print((mcomb(a + b, min(a, b))))"
] | false | 0.127189 | 0.071214 | 1.786009 | [
"s854168663",
"s145260535"
] |
u413165887 | p02713 | python | s299273910 | s264189481 | 946 | 346 | 76,128 | 76,204 | Accepted | Accepted | 63.42 | from fractions import gcd
k = int(eval(input()))
check = [[1 for _ in range(k+3)] for i in range(k+3)]
for i in range(1, k+2):
for j in range(i, k+2):
check[i][j] = gcd(i, j)
result = 0
for s in range(1, k+1):
for t in range(1, k+1):
n, m = sorted([s, t])
x = check[n][m]
for u in range(1, k+1):
y, z = sorted([x, u])
result += check[y][z]
print(result) | from fractions import gcd
k = int(eval(input()))
check = [[1 for _ in range(k+3)] for i in range(k+3)]
for i in range(1, k+2):
for j in range(1, k+2):
check[i][j] = gcd(i, j)
result = 0
for s in range(1, k+1):
for t in range(s, k+1):
x = check[s][t]
for u in range(t+1, k+1):
result += check[x][u]
result *= 6
result += k*(k+1)//2
print(result) | 16 | 16 | 428 | 399 | from fractions import gcd
k = int(eval(input()))
check = [[1 for _ in range(k + 3)] for i in range(k + 3)]
for i in range(1, k + 2):
for j in range(i, k + 2):
check[i][j] = gcd(i, j)
result = 0
for s in range(1, k + 1):
for t in range(1, k + 1):
n, m = sorted([s, t])
x = check[n][m]
for u in range(1, k + 1):
y, z = sorted([x, u])
result += check[y][z]
print(result)
| from fractions import gcd
k = int(eval(input()))
check = [[1 for _ in range(k + 3)] for i in range(k + 3)]
for i in range(1, k + 2):
for j in range(1, k + 2):
check[i][j] = gcd(i, j)
result = 0
for s in range(1, k + 1):
for t in range(s, k + 1):
x = check[s][t]
for u in range(t + 1, k + 1):
result += check[x][u]
result *= 6
result += k * (k + 1) // 2
print(result)
| false | 0 | [
"- for j in range(i, k + 2):",
"+ for j in range(1, k + 2):",
"- for t in range(1, k + 1):",
"- n, m = sorted([s, t])",
"- x = check[n][m]",
"- for u in range(1, k + 1):",
"- y, z = sorted([x, u])",
"- result += check[y][z]",
"+ for t in range(s, k + 1):",
"+ x = check[s][t]",
"+ for u in range(t + 1, k + 1):",
"+ result += check[x][u]",
"+result *= 6",
"+result += k * (k + 1) // 2"
] | false | 0.110078 | 0.060821 | 1.809865 | [
"s299273910",
"s264189481"
] |
u761529120 | p03818 | python | s712847883 | s544621961 | 209 | 94 | 58,924 | 98,248 | Accepted | Accepted | 55.02 | def main():
N = int(eval(input()))
A = list(map(int, input().split()))
set_A = set(A)
if len(set_A) % 2 == 0:
print((len(set_A)-1))
else:
print((len(set_A)))
if __name__ == "__main__":
main() | from collections import defaultdict
def main():
N = int(eval(input()))
A = list(map(int, input().split()))
A = set(A)
if len(A) % 2 == 0:
print((len(A) - 1))
else:
print((len(A)))
if __name__ == "__main__":
main() | 12 | 15 | 234 | 261 | def main():
N = int(eval(input()))
A = list(map(int, input().split()))
set_A = set(A)
if len(set_A) % 2 == 0:
print((len(set_A) - 1))
else:
print((len(set_A)))
if __name__ == "__main__":
main()
| from collections import defaultdict
def main():
N = int(eval(input()))
A = list(map(int, input().split()))
A = set(A)
if len(A) % 2 == 0:
print((len(A) - 1))
else:
print((len(A)))
if __name__ == "__main__":
main()
| false | 20 | [
"+from collections import defaultdict",
"+",
"+",
"- set_A = set(A)",
"- if len(set_A) % 2 == 0:",
"- print((len(set_A) - 1))",
"+ A = set(A)",
"+ if len(A) % 2 == 0:",
"+ print((len(A) - 1))",
"- print((len(set_A)))",
"+ print((len(A)))"
] | false | 0.033883 | 0.035945 | 0.942653 | [
"s712847883",
"s544621961"
] |
u762420987 | p02765 | python | s669039256 | s711837892 | 168 | 17 | 38,384 | 2,940 | Accepted | Accepted | 89.88 | N, R = list(map(int, input().split()))
if N >= 10:
print(R)
else:
print((R+(100*(10-N))))
| N, R = list(map(int, input().split()))
if N >= 10:
print(R)
else:
print((R + 100*(10-N)))
| 5 | 5 | 94 | 94 | N, R = list(map(int, input().split()))
if N >= 10:
print(R)
else:
print((R + (100 * (10 - N))))
| N, R = list(map(int, input().split()))
if N >= 10:
print(R)
else:
print((R + 100 * (10 - N)))
| false | 0 | [
"- print((R + (100 * (10 - N))))",
"+ print((R + 100 * (10 - N)))"
] | false | 0.135428 | 0.044938 | 3.013652 | [
"s669039256",
"s711837892"
] |
u133936772 | p02613 | python | s577396196 | s351603632 | 148 | 49 | 9,188 | 17,060 | Accepted | Accepted | 66.89 | n=int(eval(input()))
d={'AC':0,'WA':0,'TLE':0,'RE':0}
for _ in range(n): s=eval(input()); d[s]+=1
for k in d: print((k,'x',d[k])) | _,*l=open(0).read().split()
for j in ('AC','WA','TLE','RE'): print((j,'x',l.count(j))) | 4 | 2 | 118 | 85 | n = int(eval(input()))
d = {"AC": 0, "WA": 0, "TLE": 0, "RE": 0}
for _ in range(n):
s = eval(input())
d[s] += 1
for k in d:
print((k, "x", d[k]))
| _, *l = open(0).read().split()
for j in ("AC", "WA", "TLE", "RE"):
print((j, "x", l.count(j)))
| false | 50 | [
"-n = int(eval(input()))",
"-d = {\"AC\": 0, \"WA\": 0, \"TLE\": 0, \"RE\": 0}",
"-for _ in range(n):",
"- s = eval(input())",
"- d[s] += 1",
"-for k in d:",
"- print((k, \"x\", d[k]))",
"+_, *l = open(0).read().split()",
"+for j in (\"AC\", \"WA\", \"TLE\", \"RE\"):",
"+ print((j, \"x\", l.count(j)))"
] | false | 0.030388 | 0.038348 | 0.79243 | [
"s577396196",
"s351603632"
] |
u734169929 | p02612 | python | s753303980 | s899378576 | 31 | 27 | 9,136 | 9,160 | Accepted | Accepted | 12.9 | import math
N = int(eval(input()))
n = math.ceil(N/1000)
ans = (n*1000) - N
print(ans)
| import math
N = int(eval(input()))
n = math.ceil(N/1000)*1000
print((n-N)) | 7 | 5 | 89 | 71 | import math
N = int(eval(input()))
n = math.ceil(N / 1000)
ans = (n * 1000) - N
print(ans)
| import math
N = int(eval(input()))
n = math.ceil(N / 1000) * 1000
print((n - N))
| false | 28.571429 | [
"-n = math.ceil(N / 1000)",
"-ans = (n * 1000) - N",
"-print(ans)",
"+n = math.ceil(N / 1000) * 1000",
"+print((n - N))"
] | false | 0.039729 | 0.07979 | 0.497912 | [
"s753303980",
"s899378576"
] |
u371763408 | p03240 | python | s756331359 | s782848274 | 481 | 37 | 3,064 | 3,064 | Accepted | Accepted | 92.31 | n=int(eval(input()))
X=[]
Y=[]
H=[]
for i in range(n):
x,y,h=list(map(int,input().split()))
X.append(x)
Y.append(y)
H.append(h)
for x in range(101):
for y in range(101):
for i in range(n):
if H[i]>0:
h=H[i]+abs(X[i]-x)+abs(Y[i]-y)
for i in range(n):
if H[i]!=max(0,h-abs(X[i]-x)-abs(Y[i]-y)):
break
else: #for文の下のelseは(breakすることなしに)for文を抜けることができたら反映
print((x,y,h))
exit() | n=int(eval(input()))
s=[]
for i in range(n):
x,y,h=list(map(int,input().split()))
s.append([x,y,h])
s=sorted(s,key=lambda x:x[2],reverse=True)
x0,y0,h0=s[0] #少なくとも一つはhi>0だからhの最大のものを取る
for x in range(101):
for y in range(101):
H=h0+abs(x0-x)+abs(y0-y) #h0=H-abs(x0-x)+abs(y0-y)の式変形(hiが0以上の前提)
for xi,yi,hi in s:
if hi!=max(0,H-abs(xi-x)-abs(yi-y)):
break
else: #for文の下のelseは(breakすることなしに)for文を抜けることができたら反映
print((x,y,H))
exit() | 20 | 16 | 438 | 471 | n = int(eval(input()))
X = []
Y = []
H = []
for i in range(n):
x, y, h = list(map(int, input().split()))
X.append(x)
Y.append(y)
H.append(h)
for x in range(101):
for y in range(101):
for i in range(n):
if H[i] > 0:
h = H[i] + abs(X[i] - x) + abs(Y[i] - y)
for i in range(n):
if H[i] != max(0, h - abs(X[i] - x) - abs(Y[i] - y)):
break
else: # for文の下のelseは(breakすることなしに)for文を抜けることができたら反映
print((x, y, h))
exit()
| n = int(eval(input()))
s = []
for i in range(n):
x, y, h = list(map(int, input().split()))
s.append([x, y, h])
s = sorted(s, key=lambda x: x[2], reverse=True)
x0, y0, h0 = s[0] # 少なくとも一つはhi>0だからhの最大のものを取る
for x in range(101):
for y in range(101):
H = h0 + abs(x0 - x) + abs(y0 - y) # h0=H-abs(x0-x)+abs(y0-y)の式変形(hiが0以上の前提)
for xi, yi, hi in s:
if hi != max(0, H - abs(xi - x) - abs(yi - y)):
break
else: # for文の下のelseは(breakすることなしに)for文を抜けることができたら反映
print((x, y, H))
exit()
| false | 20 | [
"-X = []",
"-Y = []",
"-H = []",
"+s = []",
"- X.append(x)",
"- Y.append(y)",
"- H.append(h)",
"+ s.append([x, y, h])",
"+s = sorted(s, key=lambda x: x[2], reverse=True)",
"+x0, y0, h0 = s[0] # 少なくとも一つはhi>0だからhの最大のものを取る",
"- for i in range(n):",
"- if H[i] > 0:",
"- h = H[i] + abs(X[i] - x) + abs(Y[i] - y)",
"- for i in range(n):",
"- if H[i] != max(0, h - abs(X[i] - x) - abs(Y[i] - y)):",
"+ H = h0 + abs(x0 - x) + abs(y0 - y) # h0=H-abs(x0-x)+abs(y0-y)の式変形(hiが0以上の前提)",
"+ for xi, yi, hi in s:",
"+ if hi != max(0, H - abs(xi - x) - abs(yi - y)):",
"- print((x, y, h))",
"+ print((x, y, H))"
] | false | 0.050697 | 0.041291 | 1.227804 | [
"s756331359",
"s782848274"
] |
u057109575 | p03013 | python | s417356799 | s183344003 | 213 | 158 | 8,616 | 80,696 | Accepted | Accepted | 25.82 | N, M = list(map(int, input().split()))
A = [int(eval(input())) for _ in range(M)]
B = [-1] + A + [N + 1]
B = [B[i + 1] - B[i] - 2 for i in range(M + 1)]
total = max(B)
dp = [1, 1] + [0] * (total - 1)
for i in range(total - 1):
dp[i + 2] = (dp[i + 1] + dp[i]) % (10 ** 9 + 7)
ans = 1
for i in range(M + 1):
ans *= dp[B[i]]
ans %= 10 ** 9 + 7
print((ans if -1 not in B[1:] else 0)) |
N, M = list(map(int, input().split()))
X = [int(eval(input())) for _ in range(M)]
MOD = 10 ** 9 + 7
dp = [-1] * (N + 1)
dp[0] = 1
for i in range(M):
dp[X[i]] = 0
for i in range(N):
if dp[i + 1] < 0:
if i == 0:
dp[i + 1] = dp[i]
else:
dp[i + 1] = (dp[i] + dp[i - 1]) % MOD
print((dp[-1]))
| 16 | 18 | 403 | 343 | N, M = list(map(int, input().split()))
A = [int(eval(input())) for _ in range(M)]
B = [-1] + A + [N + 1]
B = [B[i + 1] - B[i] - 2 for i in range(M + 1)]
total = max(B)
dp = [1, 1] + [0] * (total - 1)
for i in range(total - 1):
dp[i + 2] = (dp[i + 1] + dp[i]) % (10**9 + 7)
ans = 1
for i in range(M + 1):
ans *= dp[B[i]]
ans %= 10**9 + 7
print((ans if -1 not in B[1:] else 0))
| N, M = list(map(int, input().split()))
X = [int(eval(input())) for _ in range(M)]
MOD = 10**9 + 7
dp = [-1] * (N + 1)
dp[0] = 1
for i in range(M):
dp[X[i]] = 0
for i in range(N):
if dp[i + 1] < 0:
if i == 0:
dp[i + 1] = dp[i]
else:
dp[i + 1] = (dp[i] + dp[i - 1]) % MOD
print((dp[-1]))
| false | 11.111111 | [
"-A = [int(eval(input())) for _ in range(M)]",
"-B = [-1] + A + [N + 1]",
"-B = [B[i + 1] - B[i] - 2 for i in range(M + 1)]",
"-total = max(B)",
"-dp = [1, 1] + [0] * (total - 1)",
"-for i in range(total - 1):",
"- dp[i + 2] = (dp[i + 1] + dp[i]) % (10**9 + 7)",
"-ans = 1",
"-for i in range(M + 1):",
"- ans *= dp[B[i]]",
"- ans %= 10**9 + 7",
"-print((ans if -1 not in B[1:] else 0))",
"+X = [int(eval(input())) for _ in range(M)]",
"+MOD = 10**9 + 7",
"+dp = [-1] * (N + 1)",
"+dp[0] = 1",
"+for i in range(M):",
"+ dp[X[i]] = 0",
"+for i in range(N):",
"+ if dp[i + 1] < 0:",
"+ if i == 0:",
"+ dp[i + 1] = dp[i]",
"+ else:",
"+ dp[i + 1] = (dp[i] + dp[i - 1]) % MOD",
"+print((dp[-1]))"
] | false | 0.044704 | 0.036052 | 1.239975 | [
"s417356799",
"s183344003"
] |
u342869120 | p02781 | python | s129750666 | s530291520 | 198 | 164 | 41,072 | 38,256 | Accepted | Accepted | 17.17 | # 0でない数字がちょうどK個
S = input().strip()
K = int(eval(input()))
N = len(S)
'''
桁DP
dp[i][j][k] :=
i桁目まで使って
j個の0ではない数値を使って
k=0:i桁目までSと一致
1:S未満(以下？)
'''
dp = [[[0]*2 for _ in range(K+1)] for _ in range(101)]
dp[0][0][0] = 1
for i in range(N):
for j in range(K+1):
for k in range(2):
nd = int(S[i])
# 0-9まで調べていく
for d in range(10):
ni, nj, nk = i+1, j, k
if d > 0:
nj += 1
if nj > K:
continue
if k == 0:
if d > nd:
continue
elif d != nd:
nk = 1
dp[ni][nj][nk] += dp[i][j][k]
print((sum(dp[N][K])))
| from math import factorial
N = int(eval(input()))
K = int(eval(input()))
def ncr(n, r):
if n < r:
return 0
return factorial(n) // factorial(r) // factorial(n - r)
def k1(n):
s = str(n)
return (len(s) - 1) * 9 + int(s[0])
def k2(n):
if n < 10:
return 0
s = str(n)
res = ncr(len(s)-1, 2) * 9 * 9
res += (int(s[0]) - 1) * k1(10 ** (len(s) - 1) - 1) + k1(int(s[1:]))
return res
def k3(n):
s = str(n)
res = ncr(len(s)-1, 3)*9*9*9
res += (int(s[0]) - 1) * k2(10 ** (len(s) - 1) - 1) + k2(int(s[1:]))
return res
kf = [k1, k2, k3]
print((kf[K-1](N)))
| 35 | 35 | 778 | 642 | # 0でない数字がちょうどK個
S = input().strip()
K = int(eval(input()))
N = len(S)
"""
桁DP
dp[i][j][k] :=
i桁目まで使って
j個の0ではない数値を使って
k=0:i桁目までSと一致
1:S未満(以下？)
"""
dp = [[[0] * 2 for _ in range(K + 1)] for _ in range(101)]
dp[0][0][0] = 1
for i in range(N):
for j in range(K + 1):
for k in range(2):
nd = int(S[i])
# 0-9まで調べていく
for d in range(10):
ni, nj, nk = i + 1, j, k
if d > 0:
nj += 1
if nj > K:
continue
if k == 0:
if d > nd:
continue
elif d != nd:
nk = 1
dp[ni][nj][nk] += dp[i][j][k]
print((sum(dp[N][K])))
| from math import factorial
N = int(eval(input()))
K = int(eval(input()))
def ncr(n, r):
if n < r:
return 0
return factorial(n) // factorial(r) // factorial(n - r)
def k1(n):
s = str(n)
return (len(s) - 1) * 9 + int(s[0])
def k2(n):
if n < 10:
return 0
s = str(n)
res = ncr(len(s) - 1, 2) * 9 * 9
res += (int(s[0]) - 1) * k1(10 ** (len(s) - 1) - 1) + k1(int(s[1:]))
return res
def k3(n):
s = str(n)
res = ncr(len(s) - 1, 3) * 9 * 9 * 9
res += (int(s[0]) - 1) * k2(10 ** (len(s) - 1) - 1) + k2(int(s[1:]))
return res
kf = [k1, k2, k3]
print((kf[K - 1](N)))
| false | 0 | [
"-# 0でない数字がちょうどK個",
"-S = input().strip()",
"+from math import factorial",
"+",
"+N = int(eval(input()))",
"-N = len(S)",
"-\"\"\"",
"-桁DP",
"-dp[i][j][k] :=",
"-i桁目まで使って",
"-j個の0ではない数値を使って",
"-k=0:i桁目までSと一致",
"- 1:S未満(以下？)",
"-\"\"\"",
"-dp = [[[0] * 2 for _ in range(K + 1)] for _ in range(101)]",
"-dp[0][0][0] = 1",
"-for i in range(N):",
"- for j in range(K + 1):",
"- for k in range(2):",
"- nd = int(S[i])",
"- # 0-9まで調べていく",
"- for d in range(10):",
"- ni, nj, nk = i + 1, j, k",
"- if d > 0:",
"- nj += 1",
"- if nj > K:",
"- continue",
"- if k == 0:",
"- if d > nd:",
"- continue",
"- elif d != nd:",
"- nk = 1",
"- dp[ni][nj][nk] += dp[i][j][k]",
"-print((sum(dp[N][K])))",
"+",
"+",
"+def ncr(n, r):",
"+ if n < r:",
"+ return 0",
"+ return factorial(n) // factorial(r) // factorial(n - r)",
"+",
"+",
"+def k1(n):",
"+ s = str(n)",
"+ return (len(s) - 1) * 9 + int(s[0])",
"+",
"+",
"+def k2(n):",
"+ if n < 10:",
"+ return 0",
"+ s = str(n)",
"+ res = ncr(len(s) - 1, 2) * 9 * 9",
"+ res += (int(s[0]) - 1) * k1(10 ** (len(s) - 1) - 1) + k1(int(s[1:]))",
"+ return res",
"+",
"+",
"+def k3(n):",
"+ s = str(n)",
"+ res = ncr(len(s) - 1, 3) * 9 * 9 * 9",
"+ res += (int(s[0]) - 1) * k2(10 ** (len(s) - 1) - 1) + k2(int(s[1:]))",
"+ return res",
"+",
"+",
"+kf = [k1, k2, k3]",
"+print((kf[K - 1](N)))"
] | false | 0.045339 | 0.043897 | 1.032843 | [
"s129750666",
"s530291520"
] |
u947883560 | p02720 | python | s465906600 | s671764463 | 163 | 131 | 21,828 | 12,404 | Accepted | Accepted | 19.63 | #!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**8)
INF = float("inf")
def solve(K: int):
X = set()
def rec(keta, val):
X.add(val)
if keta == 10:
return
for j in range(-1, 2):
add = (val % 10)+j
if add >= 0 and add <= 9:
rec(keta+1, val*10+add)
for i in range(1, 10):
rec(1, i)
X = sorted(X)
print((X[K-1]))
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
K = int(next(tokens)) # type: int
solve(K)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
from collections import deque
sys.setrecursionlimit(10**8)
INF = float("inf")
def solve(K: int):
h = deque([])
for i in range(1, 10):
h.append(i)
for i in range(K-1):
s = h.popleft()
for j in range(-1, 2):
add = (s % 10)+j
if 0 <= add <= 9:
h.append(s*10+add)
print((h.popleft()))
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
K = int(next(tokens)) # type: int
solve(K)
if __name__ == '__main__':
main()
| 41 | 37 | 738 | 704 | #!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**8)
INF = float("inf")
def solve(K: int):
X = set()
def rec(keta, val):
X.add(val)
if keta == 10:
return
for j in range(-1, 2):
add = (val % 10) + j
if add >= 0 and add <= 9:
rec(keta + 1, val * 10 + add)
for i in range(1, 10):
rec(1, i)
X = sorted(X)
print((X[K - 1]))
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
K = int(next(tokens)) # type: int
solve(K)
if __name__ == "__main__":
main()
| #!/usr/bin/env python3
import sys
from collections import deque
sys.setrecursionlimit(10**8)
INF = float("inf")
def solve(K: int):
h = deque([])
for i in range(1, 10):
h.append(i)
for i in range(K - 1):
s = h.popleft()
for j in range(-1, 2):
add = (s % 10) + j
if 0 <= add <= 9:
h.append(s * 10 + add)
print((h.popleft()))
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
K = int(next(tokens)) # type: int
solve(K)
if __name__ == "__main__":
main()
| false | 9.756098 | [
"+from collections import deque",
"- X = set()",
"-",
"- def rec(keta, val):",
"- X.add(val)",
"- if keta == 10:",
"- return",
"+ h = deque([])",
"+ for i in range(1, 10):",
"+ h.append(i)",
"+ for i in range(K - 1):",
"+ s = h.popleft()",
"- add = (val % 10) + j",
"- if add >= 0 and add <= 9:",
"- rec(keta + 1, val * 10 + add)",
"-",
"- for i in range(1, 10):",
"- rec(1, i)",
"- X = sorted(X)",
"- print((X[K - 1]))",
"+ add = (s % 10) + j",
"+ if 0 <= add <= 9:",
"+ h.append(s * 10 + add)",
"+ print((h.popleft()))"
] | false | 0.326287 | 0.049989 | 6.527137 | [
"s465906600",
"s671764463"
] |
u485319545 | p02820 | python | s051585784 | s769062093 | 139 | 127 | 14,116 | 14,164 | Accepted | Accepted | 8.63 | n,k=list(map(int,input().split()))
r,s,p = list(map(int,input().split()))
T=list(eval(input()))
a=[[] for i in range(k)]
for i in range(n):
a[i%k].append(T[i])
score=0
for j in range(k):
b=a[j]
flg=0
for l in range(len(b)):
if l==0:
if b[l]=='r':
score+=p
elif b[l]=='s':
score+=r
elif b[l]=='p':
score+=s
else:
if b[l-1]==b[l] and flg==0:
flg=1
continue
elif b[l-1]==b[l] and flg==1:
if b[l]=='r':
score+=p
elif b[l]=='s':
score+=r
elif b[l]=='p':
score+=s
flg=0
elif b[l-1]!=b[l]:
if b[l]=='r':
score+=p
elif b[l]=='s':
score+=r
elif b[l]=='p':
score+=s
flg=0
print(score)
| n,k=list(map(int,input().split()))
r,s,p = list(map(int,input().split()))
T=list(eval(input()))
a=[[] for i in range(k)]
for i in range(n):
a[i%k].append(T[i])
d={'r':p,'s':r,'p':s}
score=0
for j in range(k):
b=a[j]
flg=0
for l in range(len(b)):
if l==0:
score+=d[b[l]]
else:
if b[l-1]==b[l] and flg==0:
flg=1
continue
elif b[l-1]==b[l] and flg==1:
score+=d[b[l]]
elif b[l-1]!=b[l]:
score+=d[b[l]]
flg=0
print(score)
| 48 | 28 | 1,045 | 586 | n, k = list(map(int, input().split()))
r, s, p = list(map(int, input().split()))
T = list(eval(input()))
a = [[] for i in range(k)]
for i in range(n):
a[i % k].append(T[i])
score = 0
for j in range(k):
b = a[j]
flg = 0
for l in range(len(b)):
if l == 0:
if b[l] == "r":
score += p
elif b[l] == "s":
score += r
elif b[l] == "p":
score += s
else:
if b[l - 1] == b[l] and flg == 0:
flg = 1
continue
elif b[l - 1] == b[l] and flg == 1:
if b[l] == "r":
score += p
elif b[l] == "s":
score += r
elif b[l] == "p":
score += s
flg = 0
elif b[l - 1] != b[l]:
if b[l] == "r":
score += p
elif b[l] == "s":
score += r
elif b[l] == "p":
score += s
flg = 0
print(score)
| n, k = list(map(int, input().split()))
r, s, p = list(map(int, input().split()))
T = list(eval(input()))
a = [[] for i in range(k)]
for i in range(n):
a[i % k].append(T[i])
d = {"r": p, "s": r, "p": s}
score = 0
for j in range(k):
b = a[j]
flg = 0
for l in range(len(b)):
if l == 0:
score += d[b[l]]
else:
if b[l - 1] == b[l] and flg == 0:
flg = 1
continue
elif b[l - 1] == b[l] and flg == 1:
score += d[b[l]]
elif b[l - 1] != b[l]:
score += d[b[l]]
flg = 0
print(score)
| false | 41.666667 | [
"+d = {\"r\": p, \"s\": r, \"p\": s}",
"- if b[l] == \"r\":",
"- score += p",
"- elif b[l] == \"s\":",
"- score += r",
"- elif b[l] == \"p\":",
"- score += s",
"+ score += d[b[l]]",
"- if b[l] == \"r\":",
"- score += p",
"- elif b[l] == \"s\":",
"- score += r",
"- elif b[l] == \"p\":",
"- score += s",
"- flg = 0",
"+ score += d[b[l]]",
"- if b[l] == \"r\":",
"- score += p",
"- elif b[l] == \"s\":",
"- score += r",
"- elif b[l] == \"p\":",
"- score += s",
"- flg = 0",
"+ score += d[b[l]]",
"+ flg = 0"
] | false | 0.037671 | 0.036956 | 1.019369 | [
"s051585784",
"s769062093"
] |
u585742242 | p03289 | python | s578522987 | s101789189 | 19 | 17 | 3,060 | 2,940 | Accepted | Accepted | 10.53 | # -*- coding: utf-8 -*-
S = eval(input())
if S[0] != 'A':
print('WA')
elif 'C' not in S[2:-1]:
print('WA')
else:
i = S[2:-1].find('C')
S = S[1:2 + i] + S[2 + i + 1:]
if not S.islower():
print('WA')
else:
print('AC')
| # -*- coding: utf-8 -*-
S = eval(input())
if S[0] != 'A' or 'C' not in S[2:-1]:
print('WA')
else:
i = S[2:-1].find('C')
S = S[1:2 + i] + S[2 + i + 1:]
if not S.islower():
print('WA')
else:
print('AC')
| 14 | 12 | 264 | 243 | # -*- coding: utf-8 -*-
S = eval(input())
if S[0] != "A":
print("WA")
elif "C" not in S[2:-1]:
print("WA")
else:
i = S[2:-1].find("C")
S = S[1 : 2 + i] + S[2 + i + 1 :]
if not S.islower():
print("WA")
else:
print("AC")
| # -*- coding: utf-8 -*-
S = eval(input())
if S[0] != "A" or "C" not in S[2:-1]:
print("WA")
else:
i = S[2:-1].find("C")
S = S[1 : 2 + i] + S[2 + i + 1 :]
if not S.islower():
print("WA")
else:
print("AC")
| false | 14.285714 | [
"-if S[0] != \"A\":",
"- print(\"WA\")",
"-elif \"C\" not in S[2:-1]:",
"+if S[0] != \"A\" or \"C\" not in S[2:-1]:"
] | false | 0.044999 | 0.040922 | 1.099615 | [
"s578522987",
"s101789189"
] |
u844646164 | p02996 | python | s058747058 | s281480533 | 1,189 | 446 | 89,816 | 111,088 | Accepted | Accepted | 62.49 | N = int(eval(input()))
ab = [list(map(int, input().split())) for _ in range(N)]
time = 0
ab = sorted(ab, key=lambda x:x[1])
for a, b in ab:
time += a
if time <= b:
pass
else:
print('No')
exit()
print('Yes') | import sys
input = sys.stdin.readline
N = int(eval(input()))
ab = [list(map(int, input().split())) for _ in range(N)]
ab = sorted(ab, key=lambda x:x[1])
now = 0
for a, b in ab:
if now + a <= b:
now += a
else:
print('No')
exit()
print('Yes') | 12 | 14 | 229 | 264 | N = int(eval(input()))
ab = [list(map(int, input().split())) for _ in range(N)]
time = 0
ab = sorted(ab, key=lambda x: x[1])
for a, b in ab:
time += a
if time <= b:
pass
else:
print("No")
exit()
print("Yes")
| import sys
input = sys.stdin.readline
N = int(eval(input()))
ab = [list(map(int, input().split())) for _ in range(N)]
ab = sorted(ab, key=lambda x: x[1])
now = 0
for a, b in ab:
if now + a <= b:
now += a
else:
print("No")
exit()
print("Yes")
| false | 14.285714 | [
"+import sys",
"+",
"+input = sys.stdin.readline",
"-time = 0",
"+now = 0",
"- time += a",
"- if time <= b:",
"- pass",
"+ if now + a <= b:",
"+ now += a"
] | false | 0.046547 | 0.042837 | 1.086597 | [
"s058747058",
"s281480533"
] |
u440566786 | p03732 | python | s974346280 | s594457085 | 406 | 196 | 81,060 | 41,324 | Accepted | Accepted | 51.72 | import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda :sys.stdin.readline().rstrip()
from collections import defaultdict
def resolve():
n,W=list(map(int,input().split()))
WV=[tuple(map(int,input().split())) for _ in range(n)]
weight=set()
for i in range(n+1):
if(WV[0][0]*i>W): break
for j in range(3*i+1):
if(WV[0][0]*i+j>W): break
weight.add(WV[0][0]*i+j)
weight=sorted(weight)
dp=defaultdict(int)
for i in range(n):
ndp=defaultdict(int)
w,v=WV[i]
for key in weight:
ndp[key]=max(ndp[key],dp[key])
if(key+w<=W): ndp[key+w]=max(ndp[key+w],dp[key]+v)
dp=ndp
print((max(dp.values())))
resolve() | import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda :sys.stdin.readline().rstrip()
def resolve():
n,W=list(map(int,input().split()))
w0,v=list(map(int,input().split()))
V=[[] for _ in range(4)]
V[0].append(v)
for _ in range(n-1):
w,v=list(map(int,input().split()))
V[w-w0].append(v)
for i in range(4):
V[i].sort(reverse=1)
for j in range(len(V[i])-1):
V[i][j+1]+=V[i][j]
for i in range(4):
V[i].insert(0,0)
ans=0
from itertools import product
for a,b,c,d in product(list(range(len(V[0]))),list(range(len(V[1]))),list(range(len(V[2]))),list(range(len(V[3])))):
v=V[0][a]+V[1][b]+V[2][c]+V[3][d]
if(a*w0+b*(w0+1)+c*(w0+2)+d*(w0+3)<=W): ans=max(ans,v)
print(ans)
resolve() | 30 | 27 | 779 | 801 | import sys
sys.setrecursionlimit(2147483647)
INF = float("inf")
MOD = 10**9 + 7
input = lambda: sys.stdin.readline().rstrip()
from collections import defaultdict
def resolve():
n, W = list(map(int, input().split()))
WV = [tuple(map(int, input().split())) for _ in range(n)]
weight = set()
for i in range(n + 1):
if WV[0][0] * i > W:
break
for j in range(3 * i + 1):
if WV[0][0] * i + j > W:
break
weight.add(WV[0][0] * i + j)
weight = sorted(weight)
dp = defaultdict(int)
for i in range(n):
ndp = defaultdict(int)
w, v = WV[i]
for key in weight:
ndp[key] = max(ndp[key], dp[key])
if key + w <= W:
ndp[key + w] = max(ndp[key + w], dp[key] + v)
dp = ndp
print((max(dp.values())))
resolve()
| import sys
sys.setrecursionlimit(2147483647)
INF = float("inf")
MOD = 10**9 + 7
input = lambda: sys.stdin.readline().rstrip()
def resolve():
n, W = list(map(int, input().split()))
w0, v = list(map(int, input().split()))
V = [[] for _ in range(4)]
V[0].append(v)
for _ in range(n - 1):
w, v = list(map(int, input().split()))
V[w - w0].append(v)
for i in range(4):
V[i].sort(reverse=1)
for j in range(len(V[i]) - 1):
V[i][j + 1] += V[i][j]
for i in range(4):
V[i].insert(0, 0)
ans = 0
from itertools import product
for a, b, c, d in product(
list(range(len(V[0]))),
list(range(len(V[1]))),
list(range(len(V[2]))),
list(range(len(V[3]))),
):
v = V[0][a] + V[1][b] + V[2][c] + V[3][d]
if a * w0 + b * (w0 + 1) + c * (w0 + 2) + d * (w0 + 3) <= W:
ans = max(ans, v)
print(ans)
resolve()
| false | 10 | [
"-from collections import defaultdict",
"- WV = [tuple(map(int, input().split())) for _ in range(n)]",
"- weight = set()",
"- for i in range(n + 1):",
"- if WV[0][0] * i > W:",
"- break",
"- for j in range(3 * i + 1):",
"- if WV[0][0] * i + j > W:",
"- break",
"- weight.add(WV[0][0] * i + j)",
"- weight = sorted(weight)",
"- dp = defaultdict(int)",
"- for i in range(n):",
"- ndp = defaultdict(int)",
"- w, v = WV[i]",
"- for key in weight:",
"- ndp[key] = max(ndp[key], dp[key])",
"- if key + w <= W:",
"- ndp[key + w] = max(ndp[key + w], dp[key] + v)",
"- dp = ndp",
"- print((max(dp.values())))",
"+ w0, v = list(map(int, input().split()))",
"+ V = [[] for _ in range(4)]",
"+ V[0].append(v)",
"+ for _ in range(n - 1):",
"+ w, v = list(map(int, input().split()))",
"+ V[w - w0].append(v)",
"+ for i in range(4):",
"+ V[i].sort(reverse=1)",
"+ for j in range(len(V[i]) - 1):",
"+ V[i][j + 1] += V[i][j]",
"+ for i in range(4):",
"+ V[i].insert(0, 0)",
"+ ans = 0",
"+ from itertools import product",
"+",
"+ for a, b, c, d in product(",
"+ list(range(len(V[0]))),",
"+ list(range(len(V[1]))),",
"+ list(range(len(V[2]))),",
"+ list(range(len(V[3]))),",
"+ ):",
"+ v = V[0][a] + V[1][b] + V[2][c] + V[3][d]",
"+ if a * w0 + b * (w0 + 1) + c * (w0 + 2) + d * (w0 + 3) <= W:",
"+ ans = max(ans, v)",
"+ print(ans)"
] | false | 0.115188 | 0.1175 | 0.980316 | [
"s974346280",
"s594457085"
] |
u392319141 | p02804 | python | s803678863 | s478051668 | 489 | 328 | 26,716 | 19,796 | Accepted | Accepted | 32.92 | from bisect import bisect_right, bisect_left
class Combination:
def __init__(self, size, mod=10**9 + 7):
self.size = size + 2
self.mod = mod
self.fact = [1, 1] + [0] * size
self.factInv = [1, 1] + [0] * size
self.inv = [0, 1] + [0] * size
for i in range(2, self.size):
self.fact[i] = self.fact[i - 1] * i % self.mod
self.inv[i] = -self.inv[self.mod % i] * (self.mod // i) % self.mod
self.factInv[i] = self.factInv[i - 1] * self.inv[i] % self.mod
def npr(self, n, r):
if n < r or n < 0 or r < 0:
return 0
return self.fact[n] * self.factInv[n - r] % self.mod
def ncr(self, n, r):
if n < r or n < 0 or r < 0:
return 0
return self.fact[n] * (self.factInv[r] * self.factInv[n - r] % self.mod) % self.mod
def nhr(self, n, r): # 重複組合せ
return self.ncr(n + r - 1, n - 1)
def factN(self, n):
if n < 0:
return 0
return self.fact[n]
N, K = list(map(int, input().split()))
MOD = 10**9 + 7
comb = Combination(N + 100)
A = list(map(int, input().split()))
A.sort()
ans = 0
for i, a in enumerate(A):
mi = min(i, bisect_right(A, a) - 1)
mx = N - max(i + 1, bisect_left(A, a))
ans = (ans + (comb.ncr(mi, K - 1) - comb.ncr(mx, K - 1)) * a) % MOD
print(ans) | MOD = 10**9 + 7
class Combination:
def __init__(self, size):
self.size = size + 2
self.fact = [1, 1] + [0] * size
self.factInv = [1, 1] + [0] * size
self.inv = [0, 1] + [0] * size
for i in range(2, self.size):
self.fact[i] = self.fact[i - 1] * i % MOD
self.inv[i] = -self.inv[MOD % i] * (MOD // i) % MOD
self.factInv[i] = self.factInv[i - 1] * self.inv[i] % MOD
def npr(self, n, r):
if n < r or n < 0 or r < 0:
return 0
return self.fact[n] * self.factInv[n - r] % MOD
def ncr(self, n, r):
if n < r or n < 0 or r < 0:
return 0
return self.fact[n] * (self.factInv[r] * self.factInv[n - r] % MOD) % MOD
def nhr(self, n, r): # 重複組合せ: x_1 + ... + x_n = r
return self.ncr(n + r - 1, n - 1)
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
MOD = 10**9 + 7
comb = Combination(N + 10)
A.sort()
ans = 0
for i, a in enumerate(A):
mi = comb.ncr(N - i - 1, K - 1)
mx = comb.ncr(i, K - 1)
ans += (mx - mi) * a
ans %= MOD
print(ans)
| 47 | 40 | 1,395 | 1,157 | from bisect import bisect_right, bisect_left
class Combination:
def __init__(self, size, mod=10**9 + 7):
self.size = size + 2
self.mod = mod
self.fact = [1, 1] + [0] * size
self.factInv = [1, 1] + [0] * size
self.inv = [0, 1] + [0] * size
for i in range(2, self.size):
self.fact[i] = self.fact[i - 1] * i % self.mod
self.inv[i] = -self.inv[self.mod % i] * (self.mod // i) % self.mod
self.factInv[i] = self.factInv[i - 1] * self.inv[i] % self.mod
def npr(self, n, r):
if n < r or n < 0 or r < 0:
return 0
return self.fact[n] * self.factInv[n - r] % self.mod
def ncr(self, n, r):
if n < r or n < 0 or r < 0:
return 0
return (
self.fact[n] * (self.factInv[r] * self.factInv[n - r] % self.mod) % self.mod
)
def nhr(self, n, r): # 重複組合せ
return self.ncr(n + r - 1, n - 1)
def factN(self, n):
if n < 0:
return 0
return self.fact[n]
N, K = list(map(int, input().split()))
MOD = 10**9 + 7
comb = Combination(N + 100)
A = list(map(int, input().split()))
A.sort()
ans = 0
for i, a in enumerate(A):
mi = min(i, bisect_right(A, a) - 1)
mx = N - max(i + 1, bisect_left(A, a))
ans = (ans + (comb.ncr(mi, K - 1) - comb.ncr(mx, K - 1)) * a) % MOD
print(ans)
| MOD = 10**9 + 7
class Combination:
def __init__(self, size):
self.size = size + 2
self.fact = [1, 1] + [0] * size
self.factInv = [1, 1] + [0] * size
self.inv = [0, 1] + [0] * size
for i in range(2, self.size):
self.fact[i] = self.fact[i - 1] * i % MOD
self.inv[i] = -self.inv[MOD % i] * (MOD // i) % MOD
self.factInv[i] = self.factInv[i - 1] * self.inv[i] % MOD
def npr(self, n, r):
if n < r or n < 0 or r < 0:
return 0
return self.fact[n] * self.factInv[n - r] % MOD
def ncr(self, n, r):
if n < r or n < 0 or r < 0:
return 0
return self.fact[n] * (self.factInv[r] * self.factInv[n - r] % MOD) % MOD
def nhr(self, n, r): # 重複組合せ: x_1 + ... + x_n = r
return self.ncr(n + r - 1, n - 1)
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
MOD = 10**9 + 7
comb = Combination(N + 10)
A.sort()
ans = 0
for i, a in enumerate(A):
mi = comb.ncr(N - i - 1, K - 1)
mx = comb.ncr(i, K - 1)
ans += (mx - mi) * a
ans %= MOD
print(ans)
| false | 14.893617 | [
"-from bisect import bisect_right, bisect_left",
"+MOD = 10**9 + 7",
"- def __init__(self, size, mod=10**9 + 7):",
"+ def __init__(self, size):",
"- self.mod = mod",
"- self.fact[i] = self.fact[i - 1] * i % self.mod",
"- self.inv[i] = -self.inv[self.mod % i] * (self.mod // i) % self.mod",
"- self.factInv[i] = self.factInv[i - 1] * self.inv[i] % self.mod",
"+ self.fact[i] = self.fact[i - 1] * i % MOD",
"+ self.inv[i] = -self.inv[MOD % i] * (MOD // i) % MOD",
"+ self.factInv[i] = self.factInv[i - 1] * self.inv[i] % MOD",
"- return self.fact[n] * self.factInv[n - r] % self.mod",
"+ return self.fact[n] * self.factInv[n - r] % MOD",
"- return (",
"- self.fact[n] * (self.factInv[r] * self.factInv[n - r] % self.mod) % self.mod",
"- )",
"+ return self.fact[n] * (self.factInv[r] * self.factInv[n - r] % MOD) % MOD",
"- def nhr(self, n, r): # 重複組合せ",
"+ def nhr(self, n, r): # 重複組合せ: x_1 + ... + x_n = r",
"-",
"- def factN(self, n):",
"- if n < 0:",
"- return 0",
"- return self.fact[n]",
"+A = list(map(int, input().split()))",
"-comb = Combination(N + 100)",
"-A = list(map(int, input().split()))",
"+comb = Combination(N + 10)",
"- mi = min(i, bisect_right(A, a) - 1)",
"- mx = N - max(i + 1, bisect_left(A, a))",
"- ans = (ans + (comb.ncr(mi, K - 1) - comb.ncr(mx, K - 1)) * a) % MOD",
"+ mi = comb.ncr(N - i - 1, K - 1)",
"+ mx = comb.ncr(i, K - 1)",
"+ ans += (mx - mi) * a",
"+ ans %= MOD"
] | false | 0.042941 | 0.044775 | 0.959042 | [
"s803678863",
"s478051668"
] |
u790812284 | p02866 | python | s679160327 | s415308432 | 179 | 159 | 19,936 | 19,936 | Accepted | Accepted | 11.17 | import collections
import sys
n = int(eval(input()))
d = list(map(int, input().split()))
cnt = collections.Counter(d)
if d[0]!=0:
print((0))
sys.exit(0)
if cnt[0]!=1:
print((0))
sys.exit(0)
p = 1
for i in range(1,max(d)+1):
if cnt[i] == 0:
print((0))
sys.exit(0)
else:
p = (p * pow(cnt[i-1], cnt[i], 998244353))%998244353
print(p) | import collections
import sys
n = int(eval(input()))
d = list(map(int, input().split()))
cnt = collections.Counter(d)
if d[0]!=0:
print((0))
sys.exit(0)
if cnt[0]!=1:
print((0))
sys.exit(0)
p = 1
for i in range(1,max(d)+1):
p = (p * pow(cnt[i-1], cnt[i], 998244353))%998244353
print(p) | 26 | 22 | 408 | 331 | import collections
import sys
n = int(eval(input()))
d = list(map(int, input().split()))
cnt = collections.Counter(d)
if d[0] != 0:
print((0))
sys.exit(0)
if cnt[0] != 1:
print((0))
sys.exit(0)
p = 1
for i in range(1, max(d) + 1):
if cnt[i] == 0:
print((0))
sys.exit(0)
else:
p = (p * pow(cnt[i - 1], cnt[i], 998244353)) % 998244353
print(p)
| import collections
import sys
n = int(eval(input()))
d = list(map(int, input().split()))
cnt = collections.Counter(d)
if d[0] != 0:
print((0))
sys.exit(0)
if cnt[0] != 1:
print((0))
sys.exit(0)
p = 1
for i in range(1, max(d) + 1):
p = (p * pow(cnt[i - 1], cnt[i], 998244353)) % 998244353
print(p)
| false | 15.384615 | [
"- if cnt[i] == 0:",
"- print((0))",
"- sys.exit(0)",
"- else:",
"- p = (p * pow(cnt[i - 1], cnt[i], 998244353)) % 998244353",
"+ p = (p * pow(cnt[i - 1], cnt[i], 998244353)) % 998244353"
] | false | 0.04316 | 0.074527 | 0.579127 | [
"s679160327",
"s415308432"
] |
u001024152 | p03660 | python | s606207087 | s748540476 | 584 | 380 | 30,112 | 30,088 | Accepted | Accepted | 34.93 | N = int(eval(input()))
edges = [[] for _ in range(N)]
for _ in range(N-1):
s,t = [int(x)-1 for x in input().split()]
edges[s].append(t)
edges[t].append(s)
from collections import deque
def bfs(edges, s)->list:
V = len(edges)
dist = [float('inf')]*V
visited = [False]*V
dist[s] = 0
visited[s] = True
q = deque([s])
while q:
cur = q.popleft()
for nex in edges[cur]:
if visited[nex]:
continue
q.append(nex)
visited[nex] = True
dist[nex] = dist[cur] + 1
return dist
dist1 = bfs(edges, 0)
dist2 = bfs(edges, N-1)
score1 = 0
for d1,d2 in zip(dist1, dist2):
if d1 <= d2:
score1 += 1
# print(score1)
print(("Fennec" if score1 > N/2 else "Snuke"))
| import sys
from collections import deque
readline = sys.stdin.readline
N = int(readline())
edges = [[] for _ in range(N)]
for _ in range(N-1):
s,t = [int(x)-1 for x in readline().split()]
edges[s].append(t)
edges[t].append(s)
def bfs(edges, s)->list:
V = len(edges)
dist = [float('inf')]*V
visited = [False]*V
dist[s] = 0
visited[s] = True
q = deque([s])
while q:
cur = q.popleft()
for nex in edges[cur]:
if visited[nex]:
continue
q.append(nex)
visited[nex] = True
dist[nex] = dist[cur] + 1
return dist
dist1 = bfs(edges, 0)
dist2 = bfs(edges, N-1)
score1 = 0
for d1,d2 in zip(dist1, dist2):
if d1 <= d2:
score1 += 1
# print(score1)
print(("Fennec" if score1 > N/2 else "Snuke"))
| 33 | 36 | 805 | 856 | N = int(eval(input()))
edges = [[] for _ in range(N)]
for _ in range(N - 1):
s, t = [int(x) - 1 for x in input().split()]
edges[s].append(t)
edges[t].append(s)
from collections import deque
def bfs(edges, s) -> list:
V = len(edges)
dist = [float("inf")] * V
visited = [False] * V
dist[s] = 0
visited[s] = True
q = deque([s])
while q:
cur = q.popleft()
for nex in edges[cur]:
if visited[nex]:
continue
q.append(nex)
visited[nex] = True
dist[nex] = dist[cur] + 1
return dist
dist1 = bfs(edges, 0)
dist2 = bfs(edges, N - 1)
score1 = 0
for d1, d2 in zip(dist1, dist2):
if d1 <= d2:
score1 += 1
# print(score1)
print(("Fennec" if score1 > N / 2 else "Snuke"))
| import sys
from collections import deque
readline = sys.stdin.readline
N = int(readline())
edges = [[] for _ in range(N)]
for _ in range(N - 1):
s, t = [int(x) - 1 for x in readline().split()]
edges[s].append(t)
edges[t].append(s)
def bfs(edges, s) -> list:
V = len(edges)
dist = [float("inf")] * V
visited = [False] * V
dist[s] = 0
visited[s] = True
q = deque([s])
while q:
cur = q.popleft()
for nex in edges[cur]:
if visited[nex]:
continue
q.append(nex)
visited[nex] = True
dist[nex] = dist[cur] + 1
return dist
dist1 = bfs(edges, 0)
dist2 = bfs(edges, N - 1)
score1 = 0
for d1, d2 in zip(dist1, dist2):
if d1 <= d2:
score1 += 1
# print(score1)
print(("Fennec" if score1 > N / 2 else "Snuke"))
| false | 8.333333 | [
"-N = int(eval(input()))",
"+import sys",
"+from collections import deque",
"+",
"+readline = sys.stdin.readline",
"+N = int(readline())",
"- s, t = [int(x) - 1 for x in input().split()]",
"+ s, t = [int(x) - 1 for x in readline().split()]",
"-from collections import deque"
] | false | 0.05235 | 0.040148 | 1.303927 | [
"s606207087",
"s748540476"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.