user_id
stringlengths 10
10
| problem_id
stringlengths 6
6
| language
stringclasses 1
value | submission_id_v0
stringlengths 10
10
| submission_id_v1
stringlengths 10
10
| cpu_time_v0
int64 10
38.3k
| cpu_time_v1
int64 0
24.7k
| memory_v0
int64 2.57k
1.02M
| memory_v1
int64 2.57k
869k
| status_v0
stringclasses 1
value | status_v1
stringclasses 1
value | improvement_frac
float64 7.51
100
| input
stringlengths 20
4.55k
| target
stringlengths 17
3.34k
| code_v0_loc
int64 1
148
| code_v1_loc
int64 1
184
| code_v0_num_chars
int64 13
4.55k
| code_v1_num_chars
int64 14
3.34k
| code_v0_no_empty_lines
stringlengths 21
6.88k
| code_v1_no_empty_lines
stringlengths 20
4.93k
| code_same
bool 1
class | relative_loc_diff_percent
float64 0
79.8
| diff
list | diff_only_import_comment
bool 1
class | measured_runtime_v0
float64 0.01
4.45
| measured_runtime_v1
float64 0.01
4.31
| runtime_lift
float64 0
359
| key
list |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
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.