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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
u941407962
|
p02734
|
python
|
s052385495
|
s290613299
| 771 | 513 | 175,880 | 113,244 |
Accepted
|
Accepted
| 33.46 |
N, S = list(map(int, input().split()))
mod = 998244353
A = list(map(int, input().split()))
dp1 = [[0]*(S+1) for _ in range(N+1)]
dp2 = [[0]*(S+1) for _ in range(N+1)]
for i in range(1, N+1):
a = A[i-1]
dp1[i][0] = 1
for j in range(S+1):
dp1[i][j] += dp1[i-1][j]
dp2[i][j] = dp2[i-1][j]
if j == a:
dp1[i][j] += 1
if j-a >= 0:
dp1[i][j] += dp1[i-1][j-a]
dp2[i][j] += dp1[i][j]
dp1[i][j] %= mod
dp2[i][j] %= mod
print((dp2[-1][S]))
#print(dp[1])
#print(dp[2])
#print(dp[3])
|
N, S = list(map(int, input().split()))
mod = 998244353
A = list(map(int, input().split()))
dp1 = [[0]*(S+1) for _ in range(N+1)]
r = 0
for i in range(1, N+1):
a = A[i-1]
dp1[i][0] = 1
for j in range(S+1):
dp1[i][j] += dp1[i-1][j]
if j == a:
dp1[i][j] += 1
if j-a >= 0:
dp1[i][j] += dp1[i-1][j-a]
dp1[i][j] %= mod
r += dp1[i][S]
print((r%mod))
| 24 | 18 | 580 | 425 |
N, S = list(map(int, input().split()))
mod = 998244353
A = list(map(int, input().split()))
dp1 = [[0] * (S + 1) for _ in range(N + 1)]
dp2 = [[0] * (S + 1) for _ in range(N + 1)]
for i in range(1, N + 1):
a = A[i - 1]
dp1[i][0] = 1
for j in range(S + 1):
dp1[i][j] += dp1[i - 1][j]
dp2[i][j] = dp2[i - 1][j]
if j == a:
dp1[i][j] += 1
if j - a >= 0:
dp1[i][j] += dp1[i - 1][j - a]
dp2[i][j] += dp1[i][j]
dp1[i][j] %= mod
dp2[i][j] %= mod
print((dp2[-1][S]))
# print(dp[1])
# print(dp[2])
# print(dp[3])
|
N, S = list(map(int, input().split()))
mod = 998244353
A = list(map(int, input().split()))
dp1 = [[0] * (S + 1) for _ in range(N + 1)]
r = 0
for i in range(1, N + 1):
a = A[i - 1]
dp1[i][0] = 1
for j in range(S + 1):
dp1[i][j] += dp1[i - 1][j]
if j == a:
dp1[i][j] += 1
if j - a >= 0:
dp1[i][j] += dp1[i - 1][j - a]
dp1[i][j] %= mod
r += dp1[i][S]
print((r % mod))
| false | 25 |
[
"-dp2 = [[0] * (S + 1) for _ in range(N + 1)]",
"+r = 0",
"- dp2[i][j] = dp2[i - 1][j]",
"- dp2[i][j] += dp1[i][j]",
"- dp2[i][j] %= mod",
"-print((dp2[-1][S]))",
"-# print(dp[1])",
"-# print(dp[2])",
"-# print(dp[3])",
"+ r += dp1[i][S]",
"+print((r % mod))"
] | false | 0.037152 | 0.03496 | 1.062708 |
[
"s052385495",
"s290613299"
] |
u353919145
|
p03574
|
python
|
s384137848
|
s366970234
| 20 | 13 | 2,696 | 2,696 |
Accepted
|
Accepted
| 35 |
def check(b, i, j, x, y):
if i < 0 or j < 0 or i == x or j == y:
return 0
if b[i][j] == "#":
return 1
return 0
bounds = input().split(" ")
x = int(bounds[0])
y = int(bounds[1])
board = [None] * x
for i in range(0, x):
k = input()
board[i] = [None] * y
for j in range(0, y):
board[i][j] = k[j]
for i in range(0, x):
for j in range(0, y):
if board[i][j] == ".":
p = 0
p += check(board, i-1, j-1, x, y)
p += check(board, i-1, j , x, y)
p += check(board, i-1, j+1, x, y)
p += check(board, i , j-1, x, y)
p += check(board, i , j+1, x, y)
p += check(board, i+1, j-1, x, y)
p += check(board, i+1, j , x, y)
p += check(board, i+1, j+1, x, y)
board[i][j] = p
z = ""
for j in range(0, y):
z += str(board[i][j])
print(z)
|
h,w=list(map(int,input().split()))
temp=[]
e='eee'
for i in range(w-1):
e='e'+e
temp.append(e)
for i in range(h):
ip=input()
ip='e'+ip+'e'
temp.append(ip)
temp.append(e)
n=0
op=[]
fop=[]
for i in range(h):
for j in range(w):
if temp[i+1][j+1]=='.':
if temp[i+2][j+1]=='#':
n=n+1
if temp[i][j+1]=='#':
n=n+1
if temp[i+1][j+2]=='#':
n=n+1
if temp[i+1][j]=='#':
n=n+1
if temp[i+2][j+2]=='#':
n=n+1
if temp[i][j+2]=='#':
n=n+1
if temp[i+2][j]=='#':
n=n+1
if temp[i][j]=='#':
n=n+1
op.append(str(n))
n=0
elif temp[i+1][j+1]=='#':
op.append('#')
fop.append(op)
op=[]
for i in range(h):
print(''.join(fop[i]))
| 34 | 42 | 807 | 727 |
def check(b, i, j, x, y):
if i < 0 or j < 0 or i == x or j == y:
return 0
if b[i][j] == "#":
return 1
return 0
bounds = input().split(" ")
x = int(bounds[0])
y = int(bounds[1])
board = [None] * x
for i in range(0, x):
k = input()
board[i] = [None] * y
for j in range(0, y):
board[i][j] = k[j]
for i in range(0, x):
for j in range(0, y):
if board[i][j] == ".":
p = 0
p += check(board, i - 1, j - 1, x, y)
p += check(board, i - 1, j, x, y)
p += check(board, i - 1, j + 1, x, y)
p += check(board, i, j - 1, x, y)
p += check(board, i, j + 1, x, y)
p += check(board, i + 1, j - 1, x, y)
p += check(board, i + 1, j, x, y)
p += check(board, i + 1, j + 1, x, y)
board[i][j] = p
z = ""
for j in range(0, y):
z += str(board[i][j])
print(z)
|
h, w = list(map(int, input().split()))
temp = []
e = "eee"
for i in range(w - 1):
e = "e" + e
temp.append(e)
for i in range(h):
ip = input()
ip = "e" + ip + "e"
temp.append(ip)
temp.append(e)
n = 0
op = []
fop = []
for i in range(h):
for j in range(w):
if temp[i + 1][j + 1] == ".":
if temp[i + 2][j + 1] == "#":
n = n + 1
if temp[i][j + 1] == "#":
n = n + 1
if temp[i + 1][j + 2] == "#":
n = n + 1
if temp[i + 1][j] == "#":
n = n + 1
if temp[i + 2][j + 2] == "#":
n = n + 1
if temp[i][j + 2] == "#":
n = n + 1
if temp[i + 2][j] == "#":
n = n + 1
if temp[i][j] == "#":
n = n + 1
op.append(str(n))
n = 0
elif temp[i + 1][j + 1] == "#":
op.append("#")
fop.append(op)
op = []
for i in range(h):
print("".join(fop[i]))
| false | 19.047619 |
[
"-def check(b, i, j, x, y):",
"- if i < 0 or j < 0 or i == x or j == y:",
"- return 0",
"- if b[i][j] == \"#\":",
"- return 1",
"- return 0",
"-",
"-",
"-bounds = input().split(\" \")",
"-x = int(bounds[0])",
"-y = int(bounds[1])",
"-board = [None] * x",
"-for i in range(0, x):",
"- k = input()",
"- board[i] = [None] * y",
"- for j in range(0, y):",
"- board[i][j] = k[j]",
"-for i in range(0, x):",
"- for j in range(0, y):",
"- if board[i][j] == \".\":",
"- p = 0",
"- p += check(board, i - 1, j - 1, x, y)",
"- p += check(board, i - 1, j, x, y)",
"- p += check(board, i - 1, j + 1, x, y)",
"- p += check(board, i, j - 1, x, y)",
"- p += check(board, i, j + 1, x, y)",
"- p += check(board, i + 1, j - 1, x, y)",
"- p += check(board, i + 1, j, x, y)",
"- p += check(board, i + 1, j + 1, x, y)",
"- board[i][j] = p",
"- z = \"\"",
"- for j in range(0, y):",
"- z += str(board[i][j])",
"- print(z)",
"+h, w = list(map(int, input().split()))",
"+temp = []",
"+e = \"eee\"",
"+for i in range(w - 1):",
"+ e = \"e\" + e",
"+temp.append(e)",
"+for i in range(h):",
"+ ip = input()",
"+ ip = \"e\" + ip + \"e\"",
"+ temp.append(ip)",
"+temp.append(e)",
"+n = 0",
"+op = []",
"+fop = []",
"+for i in range(h):",
"+ for j in range(w):",
"+ if temp[i + 1][j + 1] == \".\":",
"+ if temp[i + 2][j + 1] == \"#\":",
"+ n = n + 1",
"+ if temp[i][j + 1] == \"#\":",
"+ n = n + 1",
"+ if temp[i + 1][j + 2] == \"#\":",
"+ n = n + 1",
"+ if temp[i + 1][j] == \"#\":",
"+ n = n + 1",
"+ if temp[i + 2][j + 2] == \"#\":",
"+ n = n + 1",
"+ if temp[i][j + 2] == \"#\":",
"+ n = n + 1",
"+ if temp[i + 2][j] == \"#\":",
"+ n = n + 1",
"+ if temp[i][j] == \"#\":",
"+ n = n + 1",
"+ op.append(str(n))",
"+ n = 0",
"+ elif temp[i + 1][j + 1] == \"#\":",
"+ op.append(\"#\")",
"+ fop.append(op)",
"+ op = []",
"+for i in range(h):",
"+ print(\"\".join(fop[i]))"
] | false | 0.045377 | 0.043441 | 1.044565 |
[
"s384137848",
"s366970234"
] |
u498487134
|
p03013
|
python
|
s102118447
|
s727740487
| 932 | 77 | 477,956 | 75,712 |
Accepted
|
Accepted
| 91.74 |
N,M=list(map(int,input().split()))
a = [int(eval(input())) for _ in range(M)]
a.append(N+1)
mod=10**9+7
fib=[1]*(N+1)
for i in range(2,N+1):
fib[i]=fib[i-1]+fib[i-2]
fib.append(0)
ans=fib[a[0]-1]
for i in range(M):
ans*=fib[a[i+1]-a[i]-2]
ans%=mod
print((ans%mod))
|
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()))
def main():
mod=10**9+7
N,M=MI()
dp=[0]*(N+1)
dp[0]=1
a=[0]*M
for i in range(M):
a[i]=I()
a.append(10**6)
cur=0#aの場所
for i in range(1,N+1):
if i==a[cur]:
cur+=1
else:
dp[i]=(dp[i-1]+dp[i-2])%mod
print((dp[-1]))
main()
| 15 | 29 | 278 | 526 |
N, M = list(map(int, input().split()))
a = [int(eval(input())) for _ in range(M)]
a.append(N + 1)
mod = 10**9 + 7
fib = [1] * (N + 1)
for i in range(2, N + 1):
fib[i] = fib[i - 1] + fib[i - 2]
fib.append(0)
ans = fib[a[0] - 1]
for i in range(M):
ans *= fib[a[i + 1] - a[i] - 2]
ans %= mod
print((ans % mod))
|
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()))
def main():
mod = 10**9 + 7
N, M = MI()
dp = [0] * (N + 1)
dp[0] = 1
a = [0] * M
for i in range(M):
a[i] = I()
a.append(10**6)
cur = 0 # aの場所
for i in range(1, N + 1):
if i == a[cur]:
cur += 1
else:
dp[i] = (dp[i - 1] + dp[i - 2]) % mod
print((dp[-1]))
main()
| false | 48.275862 |
[
"-N, M = list(map(int, input().split()))",
"-a = [int(eval(input())) for _ in range(M)]",
"-a.append(N + 1)",
"-mod = 10**9 + 7",
"-fib = [1] * (N + 1)",
"-for i in range(2, N + 1):",
"- fib[i] = fib[i - 1] + fib[i - 2]",
"-fib.append(0)",
"-ans = fib[a[0] - 1]",
"-for i in range(M):",
"- ans *= fib[a[i + 1] - a[i] - 2]",
"- ans %= mod",
"-print((ans % mod))",
"+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()))",
"+",
"+",
"+def main():",
"+ mod = 10**9 + 7",
"+ N, M = MI()",
"+ dp = [0] * (N + 1)",
"+ dp[0] = 1",
"+ a = [0] * M",
"+ for i in range(M):",
"+ a[i] = I()",
"+ a.append(10**6)",
"+ cur = 0 # aの場所",
"+ for i in range(1, N + 1):",
"+ if i == a[cur]:",
"+ cur += 1",
"+ else:",
"+ dp[i] = (dp[i - 1] + dp[i - 2]) % mod",
"+ print((dp[-1]))",
"+",
"+",
"+main()"
] | false | 0.108275 | 0.036577 | 2.96023 |
[
"s102118447",
"s727740487"
] |
u054106284
|
p03634
|
python
|
s426922009
|
s262711102
| 1,292 | 711 | 201,648 | 87,200 |
Accepted
|
Accepted
| 44.97 |
import sys
input = sys.stdin.readline
def make_Graph(N, edges):#頂点の名前はi - 1で受け付ける
graph = [ [] for i in range(N)]
for edge in edges:
a, b, c = edge
graph[a].append((b,c))
graph[b].append((a,c))
return graph
def BFS(N, graph, start):
Q = []
V = []
prev = [None] * N
dd = [float("inf")] * N
Q.append(start)
dd[start] = 0
while len(V) < N:
a = Q.pop(0)
V.append(a)
for b, c in graph[a]:
if b != prev[a]:
Q.append(b)
prev[b] = a
dd[b] = dd[a] + c
return dd
def DFS(N, graph, a, p, d):
dd[a] = d
for b, c in graph[a]:
if b == p or dd[b] != 0:
continue
else:
DFS(N, graph, b, a, d + c)
N = int(eval(input()))
sys.setrecursionlimit(1000000)
graph = [ [] for i in range(N)]
for i in range(N-1):
a, b, c = (int(j) for j in input().split())
graph[a-1].append((b-1,c))
graph[b-1].append((a-1,c))
Q, K =(int(i) for i in input().split())
dd = [0] * N
DFS(N, graph, K-1, -1, 0)
for i in range(Q):
x, y = (int(a) for a in input().split())
print((dd[x-1] + dd[y-1]))
|
import sys
input = sys.stdin.readline
def make_Graph(N, edges):#頂点の名前はi - 1で受け付ける
graph = [ [] for i in range(N)]
for edge in edges:
a, b, c = edge
graph[a].append((b,c))
graph[b].append((a,c))
return graph
def BFS(N, graph, start):
Q = []
V = []
prev = [None] * N
dd = [float("inf")] * N
Q.append(start)
dd[start] = 0
while len(V) < N:
a = Q.pop(0)
V.append(a)
for b, c in graph[a]:
if b != prev[a]:
Q.append(b)
prev[b] = a
dd[b] = dd[a] + c
return dd
def DFS(N, graph, a, p, d):
dd[a] = d
for b, c in graph[a]:
if b == p or dd[b] != 0:
continue
else:
DFS(N, graph, b, a, d + c)
N = int(eval(input()))
sys.setrecursionlimit(100)
graph = [ [] for i in range(N)]
for i in range(N-1):
a, b, c = (int(j) for j in input().split())
graph[a-1].append((b-1,c))
graph[b-1].append((a-1,c))
Q, K =(int(i) for i in input().split())
dd = [0] * N
try:
DFS(N, graph, K-1, -1, 0)
except:
dd = BFS(N, graph, K-1)
for i in range(Q):
x, y = (int(a) for a in input().split())
print((dd[x-1] + dd[y-1]))
| 54 | 57 | 1,224 | 1,268 |
import sys
input = sys.stdin.readline
def make_Graph(N, edges): # 頂点の名前はi - 1で受け付ける
graph = [[] for i in range(N)]
for edge in edges:
a, b, c = edge
graph[a].append((b, c))
graph[b].append((a, c))
return graph
def BFS(N, graph, start):
Q = []
V = []
prev = [None] * N
dd = [float("inf")] * N
Q.append(start)
dd[start] = 0
while len(V) < N:
a = Q.pop(0)
V.append(a)
for b, c in graph[a]:
if b != prev[a]:
Q.append(b)
prev[b] = a
dd[b] = dd[a] + c
return dd
def DFS(N, graph, a, p, d):
dd[a] = d
for b, c in graph[a]:
if b == p or dd[b] != 0:
continue
else:
DFS(N, graph, b, a, d + c)
N = int(eval(input()))
sys.setrecursionlimit(1000000)
graph = [[] for i in range(N)]
for i in range(N - 1):
a, b, c = (int(j) for j in input().split())
graph[a - 1].append((b - 1, c))
graph[b - 1].append((a - 1, c))
Q, K = (int(i) for i in input().split())
dd = [0] * N
DFS(N, graph, K - 1, -1, 0)
for i in range(Q):
x, y = (int(a) for a in input().split())
print((dd[x - 1] + dd[y - 1]))
|
import sys
input = sys.stdin.readline
def make_Graph(N, edges): # 頂点の名前はi - 1で受け付ける
graph = [[] for i in range(N)]
for edge in edges:
a, b, c = edge
graph[a].append((b, c))
graph[b].append((a, c))
return graph
def BFS(N, graph, start):
Q = []
V = []
prev = [None] * N
dd = [float("inf")] * N
Q.append(start)
dd[start] = 0
while len(V) < N:
a = Q.pop(0)
V.append(a)
for b, c in graph[a]:
if b != prev[a]:
Q.append(b)
prev[b] = a
dd[b] = dd[a] + c
return dd
def DFS(N, graph, a, p, d):
dd[a] = d
for b, c in graph[a]:
if b == p or dd[b] != 0:
continue
else:
DFS(N, graph, b, a, d + c)
N = int(eval(input()))
sys.setrecursionlimit(100)
graph = [[] for i in range(N)]
for i in range(N - 1):
a, b, c = (int(j) for j in input().split())
graph[a - 1].append((b - 1, c))
graph[b - 1].append((a - 1, c))
Q, K = (int(i) for i in input().split())
dd = [0] * N
try:
DFS(N, graph, K - 1, -1, 0)
except:
dd = BFS(N, graph, K - 1)
for i in range(Q):
x, y = (int(a) for a in input().split())
print((dd[x - 1] + dd[y - 1]))
| false | 5.263158 |
[
"-sys.setrecursionlimit(1000000)",
"+sys.setrecursionlimit(100)",
"-DFS(N, graph, K - 1, -1, 0)",
"+try:",
"+ DFS(N, graph, K - 1, -1, 0)",
"+except:",
"+ dd = BFS(N, graph, K - 1)"
] | false | 0.082943 | 0.045423 | 1.826014 |
[
"s426922009",
"s262711102"
] |
u391875425
|
p03339
|
python
|
s420737325
|
s484092588
| 1,579 | 219 | 20,020 | 47,472 |
Accepted
|
Accepted
| 86.13 |
import numpy
n = int(eval(input()))
s = eval(input())
a = [0]*n
ans = 10**6
for i in range(n):
if s[i] == 'W':
a[i] = 1
res = numpy.cumsum(a)
for i in range(n):
x = res[i]-str(a[i]).count('1')
y = n-i-1-(res[n-1]-res[i])
ans = min(ans,x+y)
print(ans)
|
n = int(eval(input()))
s = eval(input())
a = [0]*n
res = [0]*n
ans = 10**6
for i in range(n):
if s[i] == 'W':
a[i] = 1
res[0] = a[0]
for i in range(n-1):
res[i+1] = res[i] + a[i+1]
for i in range(n):
x = res[i]-str(a[i]).count('1')
y = n-i-1-(res[n-1]-res[i])
ans = min(ans,x+y)
print(ans)
| 14 | 16 | 275 | 320 |
import numpy
n = int(eval(input()))
s = eval(input())
a = [0] * n
ans = 10**6
for i in range(n):
if s[i] == "W":
a[i] = 1
res = numpy.cumsum(a)
for i in range(n):
x = res[i] - str(a[i]).count("1")
y = n - i - 1 - (res[n - 1] - res[i])
ans = min(ans, x + y)
print(ans)
|
n = int(eval(input()))
s = eval(input())
a = [0] * n
res = [0] * n
ans = 10**6
for i in range(n):
if s[i] == "W":
a[i] = 1
res[0] = a[0]
for i in range(n - 1):
res[i + 1] = res[i] + a[i + 1]
for i in range(n):
x = res[i] - str(a[i]).count("1")
y = n - i - 1 - (res[n - 1] - res[i])
ans = min(ans, x + y)
print(ans)
| false | 12.5 |
[
"-import numpy",
"-",
"+res = [0] * n",
"-res = numpy.cumsum(a)",
"+res[0] = a[0]",
"+for i in range(n - 1):",
"+ res[i + 1] = res[i] + a[i + 1]"
] | false | 0.229682 | 0.085512 | 2.685955 |
[
"s420737325",
"s484092588"
] |
u588341295
|
p02868
|
python
|
s223397933
|
s673215866
| 978 | 868 | 83,036 | 78,940 |
Accepted
|
Accepted
| 11.25 |
# -*- coding: utf-8 -*-
import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for k in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for k in range(c)] for k in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 998244353
class SegTree:
"""
セグメント木
1.update: i番目の値をxに更新する
2.query: 区間[l, r)の値を得る
"""
def __init__(self, n, func, intv, A=[]):
"""
:param n: 要素数(0-indexed)
:param func: 値の操作に使う関数(min, max, add, gcdなど)
:param intv: 要素の初期値(単位元)
:param A: 初期化に使うリスト(オプション)
"""
self.n = n
self.func = func
self.intv = intv
# nより大きい2の冪数
n2 = 1
while n2 < n:
n2 <<= 1
self.n2 = n2
self.tree = [self.intv] * (n2 << 1)
# 初期化の値が決まっている場合
if A:
# 1段目(最下段)の初期化
for i in range(n):
self.tree[n2+i] = A[i]
# 2段目以降の初期化
for i in range(n2-1, -1, -1):
self.tree[i] = self.func(self.tree[i*2], self.tree[i*2+1])
def update(self, i, x):
"""
i番目の値をxに更新
:param i: index(0-indexed)
:param x: update value
"""
i += self.n2
self.tree[i] = x
while i > 0:
i >>= 1
self.tree[i] = self.func(self.tree[i*2], self.tree[i*2+1])
def query(self, a, b):
"""
[a, b)の値を得る
:param a: index(0-indexed)
:param b: index(0-indexed)
"""
l = a + self.n2
r = b + self.n2
s = self.intv
while l < r:
if r & 1:
r -= 1
s = self.func(s, self.tree[r])
if l & 1:
s = self.func(s, self.tree[l])
l += 1
l >>= 1
r >>= 1
return s
def get(self, i):
""" 一点取得 """
return self.tree[i+self.n2]
def all(self):
""" 全区間[0, n)の取得 """
return self.tree[1]
N, M = MAP()
LRC = []
for i in range(M):
l, r, c = MAP()
l -= 1
r -= 1
LRC.append((l, r, c))
LRC.sort()
st = SegTree(N, min, INF)
st.update(0, 0)
for l, r, c in LRC:
mn = st.query(l, r+1)
st.update(r, min(st.get(r), mn+c))
ans = st.get(N-1)
if ans != INF:
print((st.get(N-1)))
else:
print((-1))
|
# -*- coding: utf-8 -*-
import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for k in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for k in range(c)] for k in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 998244353
class SegTree:
"""
セグメント木
1.update: i番目の値をxに更新する
2.query: 区間[l, r)の値を得る
"""
def __init__(self, n, func, intv, A=[]):
"""
:param n: 要素数(0-indexed)
:param func: 値の操作に使う関数(min, max, add, gcdなど)
:param intv: 要素の初期値(単位元)
:param A: 初期化に使うリスト(オプション)
"""
self.n = n
self.func = func
self.intv = intv
# nより大きい2の冪数
n2 = 1
while n2 < n:
n2 <<= 1
self.n2 = n2
self.tree = [self.intv] * (n2 << 1)
# 初期化の値が決まっている場合
if A:
# 1段目(最下段)の初期化
for i in range(n):
self.tree[n2+i] = A[i]
# 2段目以降の初期化
for i in range(n2-1, -1, -1):
self.tree[i] = self.func(self.tree[i*2], self.tree[i*2+1])
def update(self, i, x):
"""
i番目の値をxに更新
:param i: index(0-indexed)
:param x: update value
"""
i += self.n2
self.tree[i] = x
while i > 0:
i >>= 1
self.tree[i] = self.func(self.tree[i*2], self.tree[i*2+1])
def query(self, a, b):
"""
[a, b)の値を得る
:param a: index(0-indexed)
:param b: index(0-indexed)
"""
l = a + self.n2
r = b + self.n2
s = self.intv
while l < r:
if r & 1:
r -= 1
s = self.func(s, self.tree[r])
if l & 1:
s = self.func(s, self.tree[l])
l += 1
l >>= 1
r >>= 1
return s
def get(self, i):
""" 一点取得 """
return self.tree[i+self.n2]
def all(self):
""" 全区間[0, n)の取得 """
return self.tree[1]
N, M = MAP()
LRC = []
for i in range(M):
l, r, c = MAP()
l -= 1
r -= 1
LRC.append((l, r, c))
LRC.sort()
st = SegTree(N, min, INF)
st.update(0, 0)
for l, r, c in LRC:
mn = st.query(l, r)
if mn+c < st.get(r):
st.update(r, mn+c)
ans = st.get(N-1)
if ans != INF:
print((st.get(N-1)))
else:
print((-1))
| 111 | 112 | 2,848 | 2,860 |
# -*- coding: utf-8 -*-
import sys
def input():
return sys.stdin.readline().strip()
def list2d(a, b, c):
return [[c] * b for i in range(a)]
def list3d(a, b, c, d):
return [[[d] * c for k in range(b)] for i in range(a)]
def list4d(a, b, c, d, e):
return [[[[e] * d for k in range(c)] for k in range(b)] for i in range(a)]
def ceil(x, y=1):
return int(-(-x // y))
def INT():
return int(eval(input()))
def MAP():
return list(map(int, input().split()))
def LIST(N=None):
return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes():
print("Yes")
def No():
print("No")
def YES():
print("YES")
def NO():
print("NO")
sys.setrecursionlimit(10**9)
INF = 10**18
MOD = 998244353
class SegTree:
"""
セグメント木
1.update: i番目の値をxに更新する
2.query: 区間[l, r)の値を得る
"""
def __init__(self, n, func, intv, A=[]):
"""
:param n: 要素数(0-indexed)
:param func: 値の操作に使う関数(min, max, add, gcdなど)
:param intv: 要素の初期値(単位元)
:param A: 初期化に使うリスト(オプション)
"""
self.n = n
self.func = func
self.intv = intv
# nより大きい2の冪数
n2 = 1
while n2 < n:
n2 <<= 1
self.n2 = n2
self.tree = [self.intv] * (n2 << 1)
# 初期化の値が決まっている場合
if A:
# 1段目(最下段)の初期化
for i in range(n):
self.tree[n2 + i] = A[i]
# 2段目以降の初期化
for i in range(n2 - 1, -1, -1):
self.tree[i] = self.func(self.tree[i * 2], self.tree[i * 2 + 1])
def update(self, i, x):
"""
i番目の値をxに更新
:param i: index(0-indexed)
:param x: update value
"""
i += self.n2
self.tree[i] = x
while i > 0:
i >>= 1
self.tree[i] = self.func(self.tree[i * 2], self.tree[i * 2 + 1])
def query(self, a, b):
"""
[a, b)の値を得る
:param a: index(0-indexed)
:param b: index(0-indexed)
"""
l = a + self.n2
r = b + self.n2
s = self.intv
while l < r:
if r & 1:
r -= 1
s = self.func(s, self.tree[r])
if l & 1:
s = self.func(s, self.tree[l])
l += 1
l >>= 1
r >>= 1
return s
def get(self, i):
"""一点取得"""
return self.tree[i + self.n2]
def all(self):
"""全区間[0, n)の取得"""
return self.tree[1]
N, M = MAP()
LRC = []
for i in range(M):
l, r, c = MAP()
l -= 1
r -= 1
LRC.append((l, r, c))
LRC.sort()
st = SegTree(N, min, INF)
st.update(0, 0)
for l, r, c in LRC:
mn = st.query(l, r + 1)
st.update(r, min(st.get(r), mn + c))
ans = st.get(N - 1)
if ans != INF:
print((st.get(N - 1)))
else:
print((-1))
|
# -*- coding: utf-8 -*-
import sys
def input():
return sys.stdin.readline().strip()
def list2d(a, b, c):
return [[c] * b for i in range(a)]
def list3d(a, b, c, d):
return [[[d] * c for k in range(b)] for i in range(a)]
def list4d(a, b, c, d, e):
return [[[[e] * d for k in range(c)] for k in range(b)] for i in range(a)]
def ceil(x, y=1):
return int(-(-x // y))
def INT():
return int(eval(input()))
def MAP():
return list(map(int, input().split()))
def LIST(N=None):
return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes():
print("Yes")
def No():
print("No")
def YES():
print("YES")
def NO():
print("NO")
sys.setrecursionlimit(10**9)
INF = 10**18
MOD = 998244353
class SegTree:
"""
セグメント木
1.update: i番目の値をxに更新する
2.query: 区間[l, r)の値を得る
"""
def __init__(self, n, func, intv, A=[]):
"""
:param n: 要素数(0-indexed)
:param func: 値の操作に使う関数(min, max, add, gcdなど)
:param intv: 要素の初期値(単位元)
:param A: 初期化に使うリスト(オプション)
"""
self.n = n
self.func = func
self.intv = intv
# nより大きい2の冪数
n2 = 1
while n2 < n:
n2 <<= 1
self.n2 = n2
self.tree = [self.intv] * (n2 << 1)
# 初期化の値が決まっている場合
if A:
# 1段目(最下段)の初期化
for i in range(n):
self.tree[n2 + i] = A[i]
# 2段目以降の初期化
for i in range(n2 - 1, -1, -1):
self.tree[i] = self.func(self.tree[i * 2], self.tree[i * 2 + 1])
def update(self, i, x):
"""
i番目の値をxに更新
:param i: index(0-indexed)
:param x: update value
"""
i += self.n2
self.tree[i] = x
while i > 0:
i >>= 1
self.tree[i] = self.func(self.tree[i * 2], self.tree[i * 2 + 1])
def query(self, a, b):
"""
[a, b)の値を得る
:param a: index(0-indexed)
:param b: index(0-indexed)
"""
l = a + self.n2
r = b + self.n2
s = self.intv
while l < r:
if r & 1:
r -= 1
s = self.func(s, self.tree[r])
if l & 1:
s = self.func(s, self.tree[l])
l += 1
l >>= 1
r >>= 1
return s
def get(self, i):
"""一点取得"""
return self.tree[i + self.n2]
def all(self):
"""全区間[0, n)の取得"""
return self.tree[1]
N, M = MAP()
LRC = []
for i in range(M):
l, r, c = MAP()
l -= 1
r -= 1
LRC.append((l, r, c))
LRC.sort()
st = SegTree(N, min, INF)
st.update(0, 0)
for l, r, c in LRC:
mn = st.query(l, r)
if mn + c < st.get(r):
st.update(r, mn + c)
ans = st.get(N - 1)
if ans != INF:
print((st.get(N - 1)))
else:
print((-1))
| false | 0.892857 |
[
"- mn = st.query(l, r + 1)",
"- st.update(r, min(st.get(r), mn + c))",
"+ mn = st.query(l, r)",
"+ if mn + c < st.get(r):",
"+ st.update(r, mn + c)"
] | false | 0.044228 | 0.038138 | 1.159685 |
[
"s223397933",
"s673215866"
] |
u941753895
|
p03624
|
python
|
s016168220
|
s000185918
| 33 | 17 | 3,956 | 3,188 |
Accepted
|
Accepted
| 48.48 |
a=list('abcdefghijklmnopqrstuvwxyz')
s=list(eval(input()))
for i in s:
if a.count(i):
a.remove(i)
if len(a)==0:
print('None')
else:
print((a[0]))
|
# 入力
S=eval(input())
# a〜z
l=['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 x in l:
if x not in S:
print(x)
exit()
print('None')
| 9 | 12 | 165 | 209 |
a = list("abcdefghijklmnopqrstuvwxyz")
s = list(eval(input()))
for i in s:
if a.count(i):
a.remove(i)
if len(a) == 0:
print("None")
else:
print((a[0]))
|
# 入力
S = eval(input())
# a〜z
l = [
"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 x in l:
if x not in S:
print(x)
exit()
print("None")
| false | 25 |
[
"-a = list(\"abcdefghijklmnopqrstuvwxyz\")",
"-s = list(eval(input()))",
"-for i in s:",
"- if a.count(i):",
"- a.remove(i)",
"-if len(a) == 0:",
"- print(\"None\")",
"-else:",
"- print((a[0]))",
"+# 入力",
"+S = eval(input())",
"+# a〜z",
"+l = [",
"+ \"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 x in l:",
"+ if x not in S:",
"+ print(x)",
"+ exit()",
"+print(\"None\")"
] | false | 0.037819 | 0.037212 | 1.016316 |
[
"s016168220",
"s000185918"
] |
u935984175
|
p02913
|
python
|
s116962619
|
s294450660
| 1,104 | 191 | 3,060 | 42,352 |
Accepted
|
Accepted
| 82.7 |
def solve():
N = int(eval(input()))
S = eval(input())
ans, j = 0, 1
for i in range(N):
s = S[i:i+j]
while S[i+j:].find(s) != -1:
j += 1
s = S[i:i+j]
ans += 1
print(ans)
if __name__ == '__main__':
solve()
|
import sys
sys.setrecursionlimit(10 ** 7)
rl = sys.stdin.readline
class RollingHash:
def __init__(self, s: str, base=1007, mod=10 ** 9 + 7):
self.mod = mod
length = len(s)
self.pw = [1] * (length + 1)
self.h = [0] * (length + 1)
v = 0
for i in range(length):
self.h[i + 1] = v = (v * base + ord(s[i])) % mod
v = 1
for i in range(length):
self.pw[i + 1] = v = v * base % mod
def query(self, left, right):
return (self.h[right] - self.h[left] * self.pw[right - left]) % self.mod
def solve():
N = int(rl())
S = eval(input())
rh = RollingHash(S)
def check(t):
dist = dict()
for i in range(N - t + 1):
h = rh.query(i, i + t)
if h in dist:
if t <= i - dist[h]:
return True
else:
dist[h] = i
return False
ok, ng = 0, N // 2 + 1
while 1 < ng - ok:
mid = (ok + ng) // 2
if check(mid):
ok = mid
else:
ng = mid
print(ok)
if __name__ == '__main__':
solve()
| 17 | 53 | 287 | 1,223 |
def solve():
N = int(eval(input()))
S = eval(input())
ans, j = 0, 1
for i in range(N):
s = S[i : i + j]
while S[i + j :].find(s) != -1:
j += 1
s = S[i : i + j]
ans += 1
print(ans)
if __name__ == "__main__":
solve()
|
import sys
sys.setrecursionlimit(10**7)
rl = sys.stdin.readline
class RollingHash:
def __init__(self, s: str, base=1007, mod=10**9 + 7):
self.mod = mod
length = len(s)
self.pw = [1] * (length + 1)
self.h = [0] * (length + 1)
v = 0
for i in range(length):
self.h[i + 1] = v = (v * base + ord(s[i])) % mod
v = 1
for i in range(length):
self.pw[i + 1] = v = v * base % mod
def query(self, left, right):
return (self.h[right] - self.h[left] * self.pw[right - left]) % self.mod
def solve():
N = int(rl())
S = eval(input())
rh = RollingHash(S)
def check(t):
dist = dict()
for i in range(N - t + 1):
h = rh.query(i, i + t)
if h in dist:
if t <= i - dist[h]:
return True
else:
dist[h] = i
return False
ok, ng = 0, N // 2 + 1
while 1 < ng - ok:
mid = (ok + ng) // 2
if check(mid):
ok = mid
else:
ng = mid
print(ok)
if __name__ == "__main__":
solve()
| false | 67.924528 |
[
"+import sys",
"+",
"+sys.setrecursionlimit(10**7)",
"+rl = sys.stdin.readline",
"+",
"+",
"+class RollingHash:",
"+ def __init__(self, s: str, base=1007, mod=10**9 + 7):",
"+ self.mod = mod",
"+ length = len(s)",
"+ self.pw = [1] * (length + 1)",
"+ self.h = [0] * (length + 1)",
"+ v = 0",
"+ for i in range(length):",
"+ self.h[i + 1] = v = (v * base + ord(s[i])) % mod",
"+ v = 1",
"+ for i in range(length):",
"+ self.pw[i + 1] = v = v * base % mod",
"+",
"+ def query(self, left, right):",
"+ return (self.h[right] - self.h[left] * self.pw[right - left]) % self.mod",
"+",
"+",
"- N = int(eval(input()))",
"+ N = int(rl())",
"- ans, j = 0, 1",
"- for i in range(N):",
"- s = S[i : i + j]",
"- while S[i + j :].find(s) != -1:",
"- j += 1",
"- s = S[i : i + j]",
"- ans += 1",
"- print(ans)",
"+ rh = RollingHash(S)",
"+",
"+ def check(t):",
"+ dist = dict()",
"+ for i in range(N - t + 1):",
"+ h = rh.query(i, i + t)",
"+ if h in dist:",
"+ if t <= i - dist[h]:",
"+ return True",
"+ else:",
"+ dist[h] = i",
"+ return False",
"+",
"+ ok, ng = 0, N // 2 + 1",
"+ while 1 < ng - ok:",
"+ mid = (ok + ng) // 2",
"+ if check(mid):",
"+ ok = mid",
"+ else:",
"+ ng = mid",
"+ print(ok)"
] | false | 0.03739 | 0.037097 | 1.007876 |
[
"s116962619",
"s294450660"
] |
u941407962
|
p02902
|
python
|
s574408237
|
s561575752
| 400 | 349 | 87,536 | 87,408 |
Accepted
|
Accepted
| 12.75 |
import sys
N,M=list(map(int,input().split()))
d=[set()for _ in range(N+1)]
def f(v,h,q):
if d[v]&q:
l=[]
for x in h[::-1]:
l=[x]+l
if x in d[v]:break
L=[]
while v!=x:
for y in l:
if v in d[y]:
L=[v]+L
v=y
break
print(("\n".join(str(x)for x in[len(L)+1,x]+L[::-1])));sys.exit()
for u in d[v]:f(u,h+[u],q|{u})
for _ in range(M):a,b=list(map(int,input().split()));d[a].add(b)
v=0;exec("v+=1;f(v,[v],{v});"*N)
print((-1))
|
import sys
N,M=list(map(int,input().split()))
d=[set()for _ in range(N+1)]
def f(v,h,q):
if d[v]&q:
l=[]
for x in h:
l=[x]+l
if x in d[v]:break
L=[]
while v!=x:
for y in l:
if v in d[y]:
L=[v]+L
v=y
break
print(("\n".join(str(x)for x in[len(L)+1,x]+L)));sys.exit()
for u in d[v]:f(u,[u]+h,q|{u})
for _ in range(M):a,b=list(map(int,input().split()));d[a].add(b)
v=0;exec("v+=1;f(v,[v],{v});"*N)
print((-1))
| 21 | 21 | 461 | 449 |
import sys
N, M = list(map(int, input().split()))
d = [set() for _ in range(N + 1)]
def f(v, h, q):
if d[v] & q:
l = []
for x in h[::-1]:
l = [x] + l
if x in d[v]:
break
L = []
while v != x:
for y in l:
if v in d[y]:
L = [v] + L
v = y
break
print(("\n".join(str(x) for x in [len(L) + 1, x] + L[::-1])))
sys.exit()
for u in d[v]:
f(u, h + [u], q | {u})
for _ in range(M):
a, b = list(map(int, input().split()))
d[a].add(b)
v = 0
exec("v+=1;f(v,[v],{v});" * N)
print((-1))
|
import sys
N, M = list(map(int, input().split()))
d = [set() for _ in range(N + 1)]
def f(v, h, q):
if d[v] & q:
l = []
for x in h:
l = [x] + l
if x in d[v]:
break
L = []
while v != x:
for y in l:
if v in d[y]:
L = [v] + L
v = y
break
print(("\n".join(str(x) for x in [len(L) + 1, x] + L)))
sys.exit()
for u in d[v]:
f(u, [u] + h, q | {u})
for _ in range(M):
a, b = list(map(int, input().split()))
d[a].add(b)
v = 0
exec("v+=1;f(v,[v],{v});" * N)
print((-1))
| false | 0 |
[
"- for x in h[::-1]:",
"+ for x in h:",
"- print((\"\\n\".join(str(x) for x in [len(L) + 1, x] + L[::-1])))",
"+ print((\"\\n\".join(str(x) for x in [len(L) + 1, x] + L)))",
"- f(u, h + [u], q | {u})",
"+ f(u, [u] + h, q | {u})"
] | false | 0.038217 | 0.154767 | 0.246933 |
[
"s574408237",
"s561575752"
] |
u133936772
|
p02819
|
python
|
s724532372
|
s775231839
| 31 | 17 | 2,940 | 2,940 |
Accepted
|
Accepted
| 45.16 |
n = int(eval(input()))
while 1:
for i in range(2, n):
if n % i == 0:
break
else:
print(n)
break
n += 1
|
x=int(eval(input()))
while 1:
if all(x%i for i in range(2,int(x**.5)+1)):
print(x); break
x+=1
| 9 | 5 | 128 | 100 |
n = int(eval(input()))
while 1:
for i in range(2, n):
if n % i == 0:
break
else:
print(n)
break
n += 1
|
x = int(eval(input()))
while 1:
if all(x % i for i in range(2, int(x**0.5) + 1)):
print(x)
break
x += 1
| false | 44.444444 |
[
"-n = int(eval(input()))",
"+x = int(eval(input()))",
"- for i in range(2, n):",
"- if n % i == 0:",
"- break",
"- else:",
"- print(n)",
"+ if all(x % i for i in range(2, int(x**0.5) + 1)):",
"+ print(x)",
"- n += 1",
"+ x += 1"
] | false | 0.050973 | 0.051625 | 0.987354 |
[
"s724532372",
"s775231839"
] |
u352394527
|
p00719
|
python
|
s951695913
|
s386717685
| 2,120 | 1,950 | 7,516 | 7,512 |
Accepted
|
Accepted
| 8.02 |
INF = 10 ** 20
def search(rest, now, goal, dp, edges):
if now == goal:
return 0
if rest == ():
if now == goal:
return 0
else:
return INF
if (rest, now) in dp:
return dp[(rest, now)]
ret = INF
for i, t in enumerate(rest):
for dist, to in edges[now]:
ret = min(ret, search(tuple(v for j, v in enumerate(rest) if i != j), to, goal, dp, edges) + dist / t)
dp[(rest, now)] = ret
return ret
def main():
while True:
n, m, p, a, b = list(map(int, input().split()))
if n == 0:
break
a -= 1
b -= 1
tlst = list(map(int, input().split()))
edges = [[] for _ in range(m)]
for _ in range(p):
x, y, z = list(map(int, input().split()))
x -= 1
y -= 1
edges[x].append((z, y))
edges[y].append((z, x))
tlst.sort()
rest = tuple(tlst)
dp = {}
ans = search(rest, a, b, dp, edges)
if ans == INF:
print("Impossible")
else:
print(ans)
main()
|
INF = 10 ** 20
def search(rest, now, goal, dp, edges):
if now == goal:
return 0
if rest == ():
if now == goal:
return 0
else:
return INF
if (rest, now) in dp:
return dp[(rest, now)]
ret = INF
for i, t in enumerate(rest):
for dist, to in edges[now]:
tmp = search(tuple(v for j, v in enumerate(rest) if i != j), to, goal, dp, edges) + dist / t
if ret > tmp:
ret = tmp
dp[(rest, now)] = ret
return ret
def main():
while True:
n, m, p, a, b = list(map(int, input().split()))
if n == 0:
break
a -= 1
b -= 1
tlst = list(map(int, input().split()))
edges = [[] for _ in range(m)]
for _ in range(p):
x, y, z = list(map(int, input().split()))
x -= 1
y -= 1
edges[x].append((z, y))
edges[y].append((z, x))
tlst.sort()
rest = tuple(tlst)
dp = {}
ans = search(rest, a, b, dp, edges)
if ans == INF:
print("Impossible")
else:
print(ans)
main()
| 45 | 47 | 1,008 | 1,036 |
INF = 10**20
def search(rest, now, goal, dp, edges):
if now == goal:
return 0
if rest == ():
if now == goal:
return 0
else:
return INF
if (rest, now) in dp:
return dp[(rest, now)]
ret = INF
for i, t in enumerate(rest):
for dist, to in edges[now]:
ret = min(
ret,
search(
tuple(v for j, v in enumerate(rest) if i != j), to, goal, dp, edges
)
+ dist / t,
)
dp[(rest, now)] = ret
return ret
def main():
while True:
n, m, p, a, b = list(map(int, input().split()))
if n == 0:
break
a -= 1
b -= 1
tlst = list(map(int, input().split()))
edges = [[] for _ in range(m)]
for _ in range(p):
x, y, z = list(map(int, input().split()))
x -= 1
y -= 1
edges[x].append((z, y))
edges[y].append((z, x))
tlst.sort()
rest = tuple(tlst)
dp = {}
ans = search(rest, a, b, dp, edges)
if ans == INF:
print("Impossible")
else:
print(ans)
main()
|
INF = 10**20
def search(rest, now, goal, dp, edges):
if now == goal:
return 0
if rest == ():
if now == goal:
return 0
else:
return INF
if (rest, now) in dp:
return dp[(rest, now)]
ret = INF
for i, t in enumerate(rest):
for dist, to in edges[now]:
tmp = (
search(
tuple(v for j, v in enumerate(rest) if i != j), to, goal, dp, edges
)
+ dist / t
)
if ret > tmp:
ret = tmp
dp[(rest, now)] = ret
return ret
def main():
while True:
n, m, p, a, b = list(map(int, input().split()))
if n == 0:
break
a -= 1
b -= 1
tlst = list(map(int, input().split()))
edges = [[] for _ in range(m)]
for _ in range(p):
x, y, z = list(map(int, input().split()))
x -= 1
y -= 1
edges[x].append((z, y))
edges[y].append((z, x))
tlst.sort()
rest = tuple(tlst)
dp = {}
ans = search(rest, a, b, dp, edges)
if ans == INF:
print("Impossible")
else:
print(ans)
main()
| false | 4.255319 |
[
"- ret = min(",
"- ret,",
"+ tmp = (",
"- + dist / t,",
"+ + dist / t",
"+ if ret > tmp:",
"+ ret = tmp"
] | false | 0.130426 | 0.130034 | 1.003012 |
[
"s951695913",
"s386717685"
] |
u228232845
|
p03163
|
python
|
s603178308
|
s637629355
| 716 | 661 | 172,552 | 171,528 |
Accepted
|
Accepted
| 7.68 |
n, W = list(map(int, input().split()))
wv = [list(map(int, input().split())) for _ in range(n)]
w = [wv[i][0] for i in range(n)]
v = [wv[i][1] for i in range(n)]
inf = float('inf')
# dp[i][weight]
# := i-1番目までの品物で重さweightを超えないように選んだときの価値の総和の最大値
dp = [[0 for _ in range(W+1)] for _ in range(n+1)]
for i in range(n):
for sum_w in range(W+1):
if sum_w - w[i] >= 0:
dp[i+1][sum_w] = max(dp[i+1][sum_w], dp[i][sum_w - w[i]] + v[i])
dp[i+1][sum_w] = max(dp[i+1][sum_w], dp[i][sum_w])
print((dp[n][W]))
|
def main():
N, W = list(map(int, input().split()))
wv = [list(map(int, input().split())) for _ in range(N)]
w = [wv[i][0] for i in range(N)]
v = [wv[i][1] for i in range(N)]
vdp = [[0 for _ in range(W+1)] for _ in range(N+1)]
for i in range(N):
for weight in range(W+1):
# 品物iを（選べるなら）選ぶ
if weight >= w[i]: vdp[i+1][weight] = max(vdp[i][weight - w[i]] + v[i], vdp[i][weight])
# 品物iを選ばない
vdp[i+1][weight] = max(vdp[i+1][weight], vdp[i][weight])
print((vdp[N][W]))
if __name__ == '__main__':
main()
| 14 | 17 | 534 | 597 |
n, W = list(map(int, input().split()))
wv = [list(map(int, input().split())) for _ in range(n)]
w = [wv[i][0] for i in range(n)]
v = [wv[i][1] for i in range(n)]
inf = float("inf")
# dp[i][weight]
# := i-1番目までの品物で重さweightを超えないように選んだときの価値の総和の最大値
dp = [[0 for _ in range(W + 1)] for _ in range(n + 1)]
for i in range(n):
for sum_w in range(W + 1):
if sum_w - w[i] >= 0:
dp[i + 1][sum_w] = max(dp[i + 1][sum_w], dp[i][sum_w - w[i]] + v[i])
dp[i + 1][sum_w] = max(dp[i + 1][sum_w], dp[i][sum_w])
print((dp[n][W]))
|
def main():
N, W = list(map(int, input().split()))
wv = [list(map(int, input().split())) for _ in range(N)]
w = [wv[i][0] for i in range(N)]
v = [wv[i][1] for i in range(N)]
vdp = [[0 for _ in range(W + 1)] for _ in range(N + 1)]
for i in range(N):
for weight in range(W + 1):
# 品物iを（選べるなら）選ぶ
if weight >= w[i]:
vdp[i + 1][weight] = max(vdp[i][weight - w[i]] + v[i], vdp[i][weight])
# 品物iを選ばない
vdp[i + 1][weight] = max(vdp[i + 1][weight], vdp[i][weight])
print((vdp[N][W]))
if __name__ == "__main__":
main()
| false | 17.647059 |
[
"-n, W = list(map(int, input().split()))",
"-wv = [list(map(int, input().split())) for _ in range(n)]",
"-w = [wv[i][0] for i in range(n)]",
"-v = [wv[i][1] for i in range(n)]",
"-inf = float(\"inf\")",
"-# dp[i][weight]",
"-# := i-1番目までの品物で重さweightを超えないように選んだときの価値の総和の最大値",
"-dp = [[0 for _ in range(W + 1)] for _ in range(n + 1)]",
"-for i in range(n):",
"- for sum_w in range(W + 1):",
"- if sum_w - w[i] >= 0:",
"- dp[i + 1][sum_w] = max(dp[i + 1][sum_w], dp[i][sum_w - w[i]] + v[i])",
"- dp[i + 1][sum_w] = max(dp[i + 1][sum_w], dp[i][sum_w])",
"-print((dp[n][W]))",
"+def main():",
"+ N, W = list(map(int, input().split()))",
"+ wv = [list(map(int, input().split())) for _ in range(N)]",
"+ w = [wv[i][0] for i in range(N)]",
"+ v = [wv[i][1] for i in range(N)]",
"+ vdp = [[0 for _ in range(W + 1)] for _ in range(N + 1)]",
"+ for i in range(N):",
"+ for weight in range(W + 1):",
"+ # 品物iを（選べるなら）選ぶ",
"+ if weight >= w[i]:",
"+ vdp[i + 1][weight] = max(vdp[i][weight - w[i]] + v[i], vdp[i][weight])",
"+ # 品物iを選ばない",
"+ vdp[i + 1][weight] = max(vdp[i + 1][weight], vdp[i][weight])",
"+ print((vdp[N][W]))",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false | 0.047998 | 0.04689 | 1.023622 |
[
"s603178308",
"s637629355"
] |
u562935282
|
p03765
|
python
|
s233438355
|
s252362940
| 1,001 | 500 | 13,716 | 15,764 |
Accepted
|
Accepted
| 50.05 |
from itertools import accumulate
*S, = [1 if x == 'A' else 2 for x in eval(input())]
*T, = [1 if x == 'A' else 2 for x in eval(input())]
# A=1,B=2
acc_s = (0,) + tuple(accumulate(S))
acc_t = (0,) + tuple(accumulate(T))
Q = int(eval(input()))
for _ in range(Q):
sl, sr, tl, tr = list(map(int, input().split()))
sl -= 1
tl -= 1
diff = (acc_t[tr] - acc_t[tl]) - (acc_s[sr] - acc_s[sl])
print(('YES' if diff % 3 == 0 else 'NO'))
|
# https://atcoder.jp/contests/arc071/submissions/6325840
from itertools import accumulate
*S, = map(lambda x: 1 if x == 'A' else 2, input())
*T, = map(lambda x: 1 if x == 'A' else 2, input())
# A=1,B=2
acc_s = (0,) + tuple(accumulate(S))
acc_t = (0,) + tuple(accumulate(T))
ans = []
Q = int(input())
for _ in range(Q):
sl, sr, tl, tr = map(int, input().split())
sl -= 1
tl -= 1
diff = (acc_t[tr] - acc_t[tl]) - (acc_s[sr] - acc_s[sl])
ans.append('YES' if diff % 3 == 0 else 'NO')
print(*ans, sep='\n')
| 16 | 21 | 447 | 547 |
from itertools import accumulate
(*S,) = [1 if x == "A" else 2 for x in eval(input())]
(*T,) = [1 if x == "A" else 2 for x in eval(input())]
# A=1,B=2
acc_s = (0,) + tuple(accumulate(S))
acc_t = (0,) + tuple(accumulate(T))
Q = int(eval(input()))
for _ in range(Q):
sl, sr, tl, tr = list(map(int, input().split()))
sl -= 1
tl -= 1
diff = (acc_t[tr] - acc_t[tl]) - (acc_s[sr] - acc_s[sl])
print(("YES" if diff % 3 == 0 else "NO"))
|
# https://atcoder.jp/contests/arc071/submissions/6325840
from itertools import accumulate
(*S,) = map(lambda x: 1 if x == "A" else 2, input())
(*T,) = map(lambda x: 1 if x == "A" else 2, input())
# A=1,B=2
acc_s = (0,) + tuple(accumulate(S))
acc_t = (0,) + tuple(accumulate(T))
ans = []
Q = int(input())
for _ in range(Q):
sl, sr, tl, tr = map(int, input().split())
sl -= 1
tl -= 1
diff = (acc_t[tr] - acc_t[tl]) - (acc_s[sr] - acc_s[sl])
ans.append("YES" if diff % 3 == 0 else "NO")
print(*ans, sep="\n")
| false | 23.809524 |
[
"+# https://atcoder.jp/contests/arc071/submissions/6325840",
"-(*S,) = [1 if x == \"A\" else 2 for x in eval(input())]",
"-(*T,) = [1 if x == \"A\" else 2 for x in eval(input())]",
"+(*S,) = map(lambda x: 1 if x == \"A\" else 2, input())",
"+(*T,) = map(lambda x: 1 if x == \"A\" else 2, input())",
"-Q = int(eval(input()))",
"+ans = []",
"+Q = int(input())",
"- sl, sr, tl, tr = list(map(int, input().split()))",
"+ sl, sr, tl, tr = map(int, input().split())",
"- print((\"YES\" if diff % 3 == 0 else \"NO\"))",
"+ ans.append(\"YES\" if diff % 3 == 0 else \"NO\")",
"+print(*ans, sep=\"\\n\")"
] | false | 0.041198 | 0.040276 | 1.022907 |
[
"s233438355",
"s252362940"
] |
u762540523
|
p02793
|
python
|
s158460003
|
s624726191
| 1,979 | 1,512 | 5,092 | 6,112 |
Accepted
|
Accepted
| 23.6 |
def PrimeFactorization(m):
pf = {}
for i in range(2, int(m ** 0.5) + 1):
while m % i == 0:
pf[i] = pf.get(i, 0) + 1
m //= i
if m > 1:
pf[m] = 1
return pf
def lcmlist(l):
from collections import defaultdict
d = defaultdict(int)
for i in set(l):
for k, v in list(PrimeFactorization(i).items()):
if v > d[k]:
d[k] = v
n = 1
for k, v in list(d.items()):
n *= k ** v
return n
n=int(eval(input()))
a=list(map(int,input().split()))
x=lcmlist(a)
ans=0
for i in a:
ans+=x//i
ans%=1000000007
print(ans)
|
from fractions import gcd
from functools import reduce
n=int(eval(input()))
a=list(map(int,input().split()))
x=reduce(lambda x,y: y//gcd(x,y)*x, a)
ans=0
for i in a:
ans+=x//i
ans%=1000000007
print(ans)
| 31 | 10 | 633 | 207 |
def PrimeFactorization(m):
pf = {}
for i in range(2, int(m**0.5) + 1):
while m % i == 0:
pf[i] = pf.get(i, 0) + 1
m //= i
if m > 1:
pf[m] = 1
return pf
def lcmlist(l):
from collections import defaultdict
d = defaultdict(int)
for i in set(l):
for k, v in list(PrimeFactorization(i).items()):
if v > d[k]:
d[k] = v
n = 1
for k, v in list(d.items()):
n *= k**v
return n
n = int(eval(input()))
a = list(map(int, input().split()))
x = lcmlist(a)
ans = 0
for i in a:
ans += x // i
ans %= 1000000007
print(ans)
|
from fractions import gcd
from functools import reduce
n = int(eval(input()))
a = list(map(int, input().split()))
x = reduce(lambda x, y: y // gcd(x, y) * x, a)
ans = 0
for i in a:
ans += x // i
ans %= 1000000007
print(ans)
| false | 67.741935 |
[
"-def PrimeFactorization(m):",
"- pf = {}",
"- for i in range(2, int(m**0.5) + 1):",
"- while m % i == 0:",
"- pf[i] = pf.get(i, 0) + 1",
"- m //= i",
"- if m > 1:",
"- pf[m] = 1",
"- return pf",
"-",
"-",
"-def lcmlist(l):",
"- from collections import defaultdict",
"-",
"- d = defaultdict(int)",
"- for i in set(l):",
"- for k, v in list(PrimeFactorization(i).items()):",
"- if v > d[k]:",
"- d[k] = v",
"- n = 1",
"- for k, v in list(d.items()):",
"- n *= k**v",
"- return n",
"-",
"+from fractions import gcd",
"+from functools import reduce",
"-x = lcmlist(a)",
"+x = reduce(lambda x, y: y // gcd(x, y) * x, a)"
] | false | 0.037419 | 0.048296 | 0.774779 |
[
"s158460003",
"s624726191"
] |
u729133443
|
p03994
|
python
|
s554677190
|
s801132623
| 191 | 105 | 46,704 | 7,144 |
Accepted
|
Accepted
| 45.03 |
s=eval(input())
k=int(eval(input()))
a=[]
for t in s[:-1]:
c=123-ord(t)
if k<c or t=='a':
a.append(t)
else:
k-=c
a.append('a')
a.append(chr((ord(s[-1])-97+k)%26+97))
print((''.join(a)))
|
s,k=open(0)
k=int(k)
*l,=map(ord,s[:-1])
for i,t in enumerate(l):
j=(19-t)%26
if j<=k:k-=j;l[i]=97
l[-1]+=k%26
print(*map(chr,l),sep='')
| 12 | 8 | 200 | 147 |
s = eval(input())
k = int(eval(input()))
a = []
for t in s[:-1]:
c = 123 - ord(t)
if k < c or t == "a":
a.append(t)
else:
k -= c
a.append("a")
a.append(chr((ord(s[-1]) - 97 + k) % 26 + 97))
print(("".join(a)))
|
s, k = open(0)
k = int(k)
(*l,) = map(ord, s[:-1])
for i, t in enumerate(l):
j = (19 - t) % 26
if j <= k:
k -= j
l[i] = 97
l[-1] += k % 26
print(*map(chr, l), sep="")
| false | 33.333333 |
[
"-s = eval(input())",
"-k = int(eval(input()))",
"-a = []",
"-for t in s[:-1]:",
"- c = 123 - ord(t)",
"- if k < c or t == \"a\":",
"- a.append(t)",
"- else:",
"- k -= c",
"- a.append(\"a\")",
"-a.append(chr((ord(s[-1]) - 97 + k) % 26 + 97))",
"-print((\"\".join(a)))",
"+s, k = open(0)",
"+k = int(k)",
"+(*l,) = map(ord, s[:-1])",
"+for i, t in enumerate(l):",
"+ j = (19 - t) % 26",
"+ if j <= k:",
"+ k -= j",
"+ l[i] = 97",
"+l[-1] += k % 26",
"+print(*map(chr, l), sep=\"\")"
] | false | 0.034194 | 0.078669 | 0.434652 |
[
"s554677190",
"s801132623"
] |
u761320129
|
p03765
|
python
|
s170959276
|
s136343976
| 1,096 | 684 | 35,780 | 43,680 |
Accepted
|
Accepted
| 37.59 |
S = input()
T = input()
Q = int(input())
qs = [tuple(map(lambda x:int(x)-1,input().split())) for i in range(Q)]
smem = [0]
for c in S:
if c == 'A':
smem.append(smem[-1] + 1)
else:
smem.append(smem[-1] - 1)
tmem = [0]
for c in T:
if c == 'A':
tmem.append(tmem[-1] + 1)
else:
tmem.append(tmem[-1] - 1)
anss = []
for s1,s2,t1,t2 in qs:
a = smem[s2+1] - smem[s1]
b = tmem[t2+1] - tmem[t1]
if a%3 == b%3:
anss.append('YES')
else:
anss.append('NO')
print(*anss, sep='\n')
|
S = input()
T = input()
Q = int(input())
qs = [tuple(map(int,input().split())) for i in range(Q)]
sas = [0]
sbs = [0]
for c in S:
a = int(c=='A')
sas.append(sas[-1] + a)
sbs.append(sbs[-1] + (a^1))
tas = [0]
tbs = [0]
for c in T:
a = int(c=='A')
tas.append(tas[-1] + a)
tbs.append(tbs[-1] + (a^1))
ans = []
for a,b,c,d in qs:
sa = sas[b] - sas[a-1]
sb = sbs[b] - sbs[a-1]
ta = tas[d] - tas[c-1]
tb = tbs[d] - tbs[c-1]
s = (sb-sa)%3
t = (tb-ta)%3
ans.append('YES' if s==t else 'NO')
print(*ans, sep='\n')
| 28 | 29 | 575 | 586 |
S = input()
T = input()
Q = int(input())
qs = [tuple(map(lambda x: int(x) - 1, input().split())) for i in range(Q)]
smem = [0]
for c in S:
if c == "A":
smem.append(smem[-1] + 1)
else:
smem.append(smem[-1] - 1)
tmem = [0]
for c in T:
if c == "A":
tmem.append(tmem[-1] + 1)
else:
tmem.append(tmem[-1] - 1)
anss = []
for s1, s2, t1, t2 in qs:
a = smem[s2 + 1] - smem[s1]
b = tmem[t2 + 1] - tmem[t1]
if a % 3 == b % 3:
anss.append("YES")
else:
anss.append("NO")
print(*anss, sep="\n")
|
S = input()
T = input()
Q = int(input())
qs = [tuple(map(int, input().split())) for i in range(Q)]
sas = [0]
sbs = [0]
for c in S:
a = int(c == "A")
sas.append(sas[-1] + a)
sbs.append(sbs[-1] + (a ^ 1))
tas = [0]
tbs = [0]
for c in T:
a = int(c == "A")
tas.append(tas[-1] + a)
tbs.append(tbs[-1] + (a ^ 1))
ans = []
for a, b, c, d in qs:
sa = sas[b] - sas[a - 1]
sb = sbs[b] - sbs[a - 1]
ta = tas[d] - tas[c - 1]
tb = tbs[d] - tbs[c - 1]
s = (sb - sa) % 3
t = (tb - ta) % 3
ans.append("YES" if s == t else "NO")
print(*ans, sep="\n")
| false | 3.448276 |
[
"-qs = [tuple(map(lambda x: int(x) - 1, input().split())) for i in range(Q)]",
"-smem = [0]",
"+qs = [tuple(map(int, input().split())) for i in range(Q)]",
"+sas = [0]",
"+sbs = [0]",
"- if c == \"A\":",
"- smem.append(smem[-1] + 1)",
"- else:",
"- smem.append(smem[-1] - 1)",
"-tmem = [0]",
"+ a = int(c == \"A\")",
"+ sas.append(sas[-1] + a)",
"+ sbs.append(sbs[-1] + (a ^ 1))",
"+tas = [0]",
"+tbs = [0]",
"- if c == \"A\":",
"- tmem.append(tmem[-1] + 1)",
"- else:",
"- tmem.append(tmem[-1] - 1)",
"-anss = []",
"-for s1, s2, t1, t2 in qs:",
"- a = smem[s2 + 1] - smem[s1]",
"- b = tmem[t2 + 1] - tmem[t1]",
"- if a % 3 == b % 3:",
"- anss.append(\"YES\")",
"- else:",
"- anss.append(\"NO\")",
"-print(*anss, sep=\"\\n\")",
"+ a = int(c == \"A\")",
"+ tas.append(tas[-1] + a)",
"+ tbs.append(tbs[-1] + (a ^ 1))",
"+ans = []",
"+for a, b, c, d in qs:",
"+ sa = sas[b] - sas[a - 1]",
"+ sb = sbs[b] - sbs[a - 1]",
"+ ta = tas[d] - tas[c - 1]",
"+ tb = tbs[d] - tbs[c - 1]",
"+ s = (sb - sa) % 3",
"+ t = (tb - ta) % 3",
"+ ans.append(\"YES\" if s == t else \"NO\")",
"+print(*ans, sep=\"\\n\")"
] | false | 0.040684 | 0.074819 | 0.543772 |
[
"s170959276",
"s136343976"
] |
u298297089
|
p03480
|
python
|
s231663549
|
s632446158
| 63 | 17 | 3,188 | 3,188 |
Accepted
|
Accepted
| 73.02 |
S = eval(input())
if S.count('1') == 0 or S.count('0') == 0:
print((len(S)))
exit()
c = S[0]
len_s = len(S)
mx = len_s
for s in range(1,len_s):
if c != S[s]:
mx = min(mx, max(len_s -s, s))
c = S[s]
print(mx)
|
# https://atcoder.jp/contests/abc083/submissions/1917434
# i i+1 が異なる場所は中間から探すだけでいい
s=eval(input())
a=s[(len(s)-1)//2::-1]
b=s[len(s)//2:]
if a[0]!=b[0]:
print((len(s)//2))
else:
c=str(1-int(a[0]))
m = (a+c).find(c)
n = (b+c).find(c)
print((len(s)//2+min(m,n)))
| 13 | 12 | 237 | 283 |
S = eval(input())
if S.count("1") == 0 or S.count("0") == 0:
print((len(S)))
exit()
c = S[0]
len_s = len(S)
mx = len_s
for s in range(1, len_s):
if c != S[s]:
mx = min(mx, max(len_s - s, s))
c = S[s]
print(mx)
|
# https://atcoder.jp/contests/abc083/submissions/1917434
# i i+1 が異なる場所は中間から探すだけでいい
s = eval(input())
a = s[(len(s) - 1) // 2 :: -1]
b = s[len(s) // 2 :]
if a[0] != b[0]:
print((len(s) // 2))
else:
c = str(1 - int(a[0]))
m = (a + c).find(c)
n = (b + c).find(c)
print((len(s) // 2 + min(m, n)))
| false | 7.692308 |
[
"-S = eval(input())",
"-if S.count(\"1\") == 0 or S.count(\"0\") == 0:",
"- print((len(S)))",
"- exit()",
"-c = S[0]",
"-len_s = len(S)",
"-mx = len_s",
"-for s in range(1, len_s):",
"- if c != S[s]:",
"- mx = min(mx, max(len_s - s, s))",
"- c = S[s]",
"-print(mx)",
"+# https://atcoder.jp/contests/abc083/submissions/1917434",
"+# i i+1 が異なる場所は中間から探すだけでいい",
"+s = eval(input())",
"+a = s[(len(s) - 1) // 2 :: -1]",
"+b = s[len(s) // 2 :]",
"+if a[0] != b[0]:",
"+ print((len(s) // 2))",
"+else:",
"+ c = str(1 - int(a[0]))",
"+ m = (a + c).find(c)",
"+ n = (b + c).find(c)",
"+ print((len(s) // 2 + min(m, n)))"
] | false | 0.141081 | 0.035259 | 4.001269 |
[
"s231663549",
"s632446158"
] |
u505493564
|
p02573
|
python
|
s291814339
|
s511171856
| 628 | 512 | 72,888 | 72,796 |
Accepted
|
Accepted
| 18.47 |
# union find, bfs
import sys
from collections import deque
si = sys.stdin.readline
def main():
[n, m] = [int(e) for e in si().split()]
if not m:
print((1))
return
visited = [False]*(n+1)
fm = [set() for _ in range(n+1)]
mx, comp = 0, 0
while m:
m -= 1
[a, b] = [int(e) for e in si().split()]
fm[a].add(b)
fm[b].add(a)
for i in range(1, n+1):
if visited[i]:
continue
visited[i] = True
comp += 1
q = deque()
q.append(i)
cnt = 1
while q:
curr = q.popleft()
for e in fm[curr]:
if not visited[e]:
visited[e] = True
q.append(e)
cnt += 1
mx = max(mx, cnt)
print(mx)
if __name__ == '__main__':
main()
|
# union find, bfs
import sys
from collections import deque
si = sys.stdin.readline
def main():
[n, m] = [int(e) for e in si().split()]
if not m:
print((1))
return
visited = [False]*(n+1)
fm = [set() for _ in range(n+1)]
mx = 0
while m:
m -= 1
[a, b] = [int(e) for e in si().split()]
fm[a].add(b)
fm[b].add(a)
for i in range(1, n+1):
if visited[i]:
continue
visited[i] = True
q = deque()
q.append(i)
cnt = 1
while q:
curr = q.popleft()
for e in fm[curr]:
if not visited[e]:
visited[e] = True
q.append(e)
cnt += 1
mx = max(mx, cnt)
print(mx)
if __name__ == '__main__':
main()
| 43 | 42 | 900 | 872 |
# union find, bfs
import sys
from collections import deque
si = sys.stdin.readline
def main():
[n, m] = [int(e) for e in si().split()]
if not m:
print((1))
return
visited = [False] * (n + 1)
fm = [set() for _ in range(n + 1)]
mx, comp = 0, 0
while m:
m -= 1
[a, b] = [int(e) for e in si().split()]
fm[a].add(b)
fm[b].add(a)
for i in range(1, n + 1):
if visited[i]:
continue
visited[i] = True
comp += 1
q = deque()
q.append(i)
cnt = 1
while q:
curr = q.popleft()
for e in fm[curr]:
if not visited[e]:
visited[e] = True
q.append(e)
cnt += 1
mx = max(mx, cnt)
print(mx)
if __name__ == "__main__":
main()
|
# union find, bfs
import sys
from collections import deque
si = sys.stdin.readline
def main():
[n, m] = [int(e) for e in si().split()]
if not m:
print((1))
return
visited = [False] * (n + 1)
fm = [set() for _ in range(n + 1)]
mx = 0
while m:
m -= 1
[a, b] = [int(e) for e in si().split()]
fm[a].add(b)
fm[b].add(a)
for i in range(1, n + 1):
if visited[i]:
continue
visited[i] = True
q = deque()
q.append(i)
cnt = 1
while q:
curr = q.popleft()
for e in fm[curr]:
if not visited[e]:
visited[e] = True
q.append(e)
cnt += 1
mx = max(mx, cnt)
print(mx)
if __name__ == "__main__":
main()
| false | 2.325581 |
[
"- mx, comp = 0, 0",
"+ mx = 0",
"- comp += 1"
] | false | 0.041521 | 0.040556 | 1.023796 |
[
"s291814339",
"s511171856"
] |
u699089116
|
p03273
|
python
|
s639752644
|
s495765981
| 186 | 162 | 38,256 | 14,292 |
Accepted
|
Accepted
| 12.9 |
h, w = list(map(int, input().split()))
a = [list(eval(input())) for _ in range(h)]
l = []
for i, v in enumerate(a):
if "#" not in v:
l.append(i)
for i in l[::-1]:
a.pop(i)
a = list(zip(*a))
l = []
for i, v in enumerate(a):
if "#" not in v:
l.append(i)
for i in l[::-1]:
a.pop(i)
a = list(zip(*a))
for i in a:
print(("".join(i)))
|
import numpy as np
h, w = list(map(int, input().split()))
a = [list(eval(input())) for _ in range(h)]
a = np.array(a).reshape(h, w)
a = [i for i in a if "#" in i]
a = np.array(a).T
a = [i for i in a if "#" in i]
a = np.array(a).T
for i in a:
print(("".join(i)))
| 21 | 13 | 373 | 267 |
h, w = list(map(int, input().split()))
a = [list(eval(input())) for _ in range(h)]
l = []
for i, v in enumerate(a):
if "#" not in v:
l.append(i)
for i in l[::-1]:
a.pop(i)
a = list(zip(*a))
l = []
for i, v in enumerate(a):
if "#" not in v:
l.append(i)
for i in l[::-1]:
a.pop(i)
a = list(zip(*a))
for i in a:
print(("".join(i)))
|
import numpy as np
h, w = list(map(int, input().split()))
a = [list(eval(input())) for _ in range(h)]
a = np.array(a).reshape(h, w)
a = [i for i in a if "#" in i]
a = np.array(a).T
a = [i for i in a if "#" in i]
a = np.array(a).T
for i in a:
print(("".join(i)))
| false | 38.095238 |
[
"+import numpy as np",
"+",
"-l = []",
"-for i, v in enumerate(a):",
"- if \"#\" not in v:",
"- l.append(i)",
"-for i in l[::-1]:",
"- a.pop(i)",
"-a = list(zip(*a))",
"-l = []",
"-for i, v in enumerate(a):",
"- if \"#\" not in v:",
"- l.append(i)",
"-for i in l[::-1]:",
"- a.pop(i)",
"-a = list(zip(*a))",
"+a = np.array(a).reshape(h, w)",
"+a = [i for i in a if \"#\" in i]",
"+a = np.array(a).T",
"+a = [i for i in a if \"#\" in i]",
"+a = np.array(a).T"
] | false | 0.035524 | 0.198792 | 0.1787 |
[
"s639752644",
"s495765981"
] |
u729133443
|
p02788
|
python
|
s641440863
|
s684822002
| 927 | 549 | 48,852 | 55,624 |
Accepted
|
Accepted
| 40.78 |
from bisect import*
n,d,a,*t=list(map(int,open(0).read().split()))
c=[0]*-~n
z=sorted(zip(*[iter(t)]*2))
s=0
for i,(x,h)in enumerate(z):c[i]+=c[i-1];h-=c[i];t=min(-h//a,0);c[i]-=t*a;c[bisect(z,(x+d+d,9e9))]+=t*a;s-=t
print(s)
|
def main():
import sys
from bisect import bisect
from operator import itemgetter
b=sys.stdin.buffer
n,d,a=list(map(int,b.readline().split()))
m=list(map(int,b.read().split()))
c=[0]*(n+1)
d*=2
z=sorted(zip(m,m),key=itemgetter(0))
y=[x for x,_ in z]
s=0
for i,(x,h)in enumerate(z):
c[i]+=c[i-1]
h-=c[i]
t=-h//a
if t>0:t=0
c[i]-=t*a
c[bisect(y,x+d)]+=t*a
s-=t
print(s)
main()
| 7 | 22 | 225 | 490 |
from bisect import *
n, d, a, *t = list(map(int, open(0).read().split()))
c = [0] * -~n
z = sorted(zip(*[iter(t)] * 2))
s = 0
for i, (x, h) in enumerate(z):
c[i] += c[i - 1]
h -= c[i]
t = min(-h // a, 0)
c[i] -= t * a
c[bisect(z, (x + d + d, 9e9))] += t * a
s -= t
print(s)
|
def main():
import sys
from bisect import bisect
from operator import itemgetter
b = sys.stdin.buffer
n, d, a = list(map(int, b.readline().split()))
m = list(map(int, b.read().split()))
c = [0] * (n + 1)
d *= 2
z = sorted(zip(m, m), key=itemgetter(0))
y = [x for x, _ in z]
s = 0
for i, (x, h) in enumerate(z):
c[i] += c[i - 1]
h -= c[i]
t = -h // a
if t > 0:
t = 0
c[i] -= t * a
c[bisect(y, x + d)] += t * a
s -= t
print(s)
main()
| false | 68.181818 |
[
"-from bisect import *",
"+def main():",
"+ import sys",
"+ from bisect import bisect",
"+ from operator import itemgetter",
"-n, d, a, *t = list(map(int, open(0).read().split()))",
"-c = [0] * -~n",
"-z = sorted(zip(*[iter(t)] * 2))",
"-s = 0",
"-for i, (x, h) in enumerate(z):",
"- c[i] += c[i - 1]",
"- h -= c[i]",
"- t = min(-h // a, 0)",
"- c[i] -= t * a",
"- c[bisect(z, (x + d + d, 9e9))] += t * a",
"- s -= t",
"-print(s)",
"+ b = sys.stdin.buffer",
"+ n, d, a = list(map(int, b.readline().split()))",
"+ m = list(map(int, b.read().split()))",
"+ c = [0] * (n + 1)",
"+ d *= 2",
"+ z = sorted(zip(m, m), key=itemgetter(0))",
"+ y = [x for x, _ in z]",
"+ s = 0",
"+ for i, (x, h) in enumerate(z):",
"+ c[i] += c[i - 1]",
"+ h -= c[i]",
"+ t = -h // a",
"+ if t > 0:",
"+ t = 0",
"+ c[i] -= t * a",
"+ c[bisect(y, x + d)] += t * a",
"+ s -= t",
"+ print(s)",
"+",
"+",
"+main()"
] | false | 0.037102 | 0.046354 | 0.800395 |
[
"s641440863",
"s684822002"
] |
u581187895
|
p02735
|
python
|
s739146528
|
s695665918
| 222 | 38 | 9,568 | 9,112 |
Accepted
|
Accepted
| 82.88 |
from collections import deque
def resolve():
INF = 1 << 60
H, W = list(map(int, input().split()))
G = [eval(input()) for _ in range(H)]
dist = [[INF] * W for _ in range(H)]
dist[0][0] = 0 if G[0][0] == "." else 1
q = deque()
q.append((dist[0][0], 0, 0))
drc = [(1, 0), (0, 1)]
while q:
cost, y, x = q.popleft()
for dy, dx in drc:
ny = y + dy
nx = x + dx
if y + dy >= H or x + dx >= W:
continue
nx_cost = cost if G[y][x] == G[ny][nx] else cost + 1
if nx_cost < dist[ny][nx]:
dist[ny][nx] = nx_cost
q.append((dist[ny][nx], ny, nx))
ans = (dist[H - 1][W - 1] + 1) // 2
print(ans)
if __name__ == "__main__":
resolve()
|
def resolve():
INF = 1 << 60
H, W = list(map(int, input().split()))
G = [eval(input()) for _ in range(H)]
# 長方形区域を選んで、その中の通路と壁を反転する操作ができる
# dp[ y ][ x ] := マス (y, x) に到達するまでに魔法を唱える回数の最小値
dp = [[INF] * W for _ in range(H)]
if G[0][0] == "#":
dp[0][0] = 1
else:
dp[0][0] = 0
# 1, (nx, ny) が通路のとき, 操作なし
# 2, (nx, ny) か壁で、(x, y) が通路のとき, 操作する
# 3, (nx, ny) が壁で、(x, y) も壁のとき, 2の操作が継続中
drc = [(0, 1), (1, 0)]
for y in range(H):
for x in range(W):
for dy, dx in drc:
ny = y + dy
nx = x + dx
if ny >= H or nx >= W:
continue
cost = 0
if G[ny][nx] == "#" and G[y][x] == ".":
cost = 1
dp[ny][nx] = min(dp[ny][nx], dp[y][x] + cost)
print((dp[H - 1][W - 1]))
if __name__ == "__main__":
resolve()
| 31 | 37 | 810 | 943 |
from collections import deque
def resolve():
INF = 1 << 60
H, W = list(map(int, input().split()))
G = [eval(input()) for _ in range(H)]
dist = [[INF] * W for _ in range(H)]
dist[0][0] = 0 if G[0][0] == "." else 1
q = deque()
q.append((dist[0][0], 0, 0))
drc = [(1, 0), (0, 1)]
while q:
cost, y, x = q.popleft()
for dy, dx in drc:
ny = y + dy
nx = x + dx
if y + dy >= H or x + dx >= W:
continue
nx_cost = cost if G[y][x] == G[ny][nx] else cost + 1
if nx_cost < dist[ny][nx]:
dist[ny][nx] = nx_cost
q.append((dist[ny][nx], ny, nx))
ans = (dist[H - 1][W - 1] + 1) // 2
print(ans)
if __name__ == "__main__":
resolve()
|
def resolve():
INF = 1 << 60
H, W = list(map(int, input().split()))
G = [eval(input()) for _ in range(H)]
# 長方形区域を選んで、その中の通路と壁を反転する操作ができる
# dp[ y ][ x ] := マス (y, x) に到達するまでに魔法を唱える回数の最小値
dp = [[INF] * W for _ in range(H)]
if G[0][0] == "#":
dp[0][0] = 1
else:
dp[0][0] = 0
# 1, (nx, ny) が通路のとき, 操作なし
# 2, (nx, ny) か壁で、(x, y) が通路のとき, 操作する
# 3, (nx, ny) が壁で、(x, y) も壁のとき, 2の操作が継続中
drc = [(0, 1), (1, 0)]
for y in range(H):
for x in range(W):
for dy, dx in drc:
ny = y + dy
nx = x + dx
if ny >= H or nx >= W:
continue
cost = 0
if G[ny][nx] == "#" and G[y][x] == ".":
cost = 1
dp[ny][nx] = min(dp[ny][nx], dp[y][x] + cost)
print((dp[H - 1][W - 1]))
if __name__ == "__main__":
resolve()
| false | 16.216216 |
[
"-from collections import deque",
"-",
"-",
"- dist = [[INF] * W for _ in range(H)]",
"- dist[0][0] = 0 if G[0][0] == \".\" else 1",
"- q = deque()",
"- q.append((dist[0][0], 0, 0))",
"- drc = [(1, 0), (0, 1)]",
"- while q:",
"- cost, y, x = q.popleft()",
"- for dy, dx in drc:",
"- ny = y + dy",
"- nx = x + dx",
"- if y + dy >= H or x + dx >= W:",
"- continue",
"- nx_cost = cost if G[y][x] == G[ny][nx] else cost + 1",
"- if nx_cost < dist[ny][nx]:",
"- dist[ny][nx] = nx_cost",
"- q.append((dist[ny][nx], ny, nx))",
"- ans = (dist[H - 1][W - 1] + 1) // 2",
"- print(ans)",
"+ # 長方形区域を選んで、その中の通路と壁を反転する操作ができる",
"+ # dp[ y ][ x ] := マス (y, x) に到達するまでに魔法を唱える回数の最小値",
"+ dp = [[INF] * W for _ in range(H)]",
"+ if G[0][0] == \"#\":",
"+ dp[0][0] = 1",
"+ else:",
"+ dp[0][0] = 0",
"+ # 1, (nx, ny) が通路のとき, 操作なし",
"+ # 2, (nx, ny) か壁で、(x, y) が通路のとき, 操作する",
"+ # 3, (nx, ny) が壁で、(x, y) も壁のとき, 2の操作が継続中",
"+ drc = [(0, 1), (1, 0)]",
"+ for y in range(H):",
"+ for x in range(W):",
"+ for dy, dx in drc:",
"+ ny = y + dy",
"+ nx = x + dx",
"+ if ny >= H or nx >= W:",
"+ continue",
"+ cost = 0",
"+ if G[ny][nx] == \"#\" and G[y][x] == \".\":",
"+ cost = 1",
"+ dp[ny][nx] = min(dp[ny][nx], dp[y][x] + cost)",
"+ print((dp[H - 1][W - 1]))"
] | false | 0.106733 | 0.036151 | 2.952412 |
[
"s739146528",
"s695665918"
] |
u339191823
|
p02389
|
python
|
s534671436
|
s187317384
| 20 | 10 | 7,528 | 6,356 |
Accepted
|
Accepted
| 50 |
t,y=list(map(int,input().split()))
print((t*y, 2*(t+y)))
|
t,y=list(map(int,input().split()))
print(t*y, 2*(t+y))
| 2 | 2 | 50 | 52 |
t, y = list(map(int, input().split()))
print((t * y, 2 * (t + y)))
|
t, y = list(map(int, input().split()))
print(t * y, 2 * (t + y))
| false | 0 |
[
"-print((t * y, 2 * (t + y)))",
"+print(t * y, 2 * (t + y))"
] | false | 0.043975 | 0.044018 | 0.999023 |
[
"s534671436",
"s187317384"
] |
u893063840
|
p02702
|
python
|
s846087139
|
s488633095
| 545 | 133 | 24,420 | 16,720 |
Accepted
|
Accepted
| 75.6 |
from collections import Counter
def f(mod):
ret = [0]
power = 1
num = 0
for i, e in enumerate(s, 1):
num *= 10
num += int(e)
num %= mod
power *= 10
power %= mod
inv = pow(power, mod - 2, mod)
ret.append(num * inv % mod)
return ret
s = eval(input())
mod3 = f(3)
mod673 = f(673)
li = [10 * e673 + e3 for e3, e673 in zip(mod3, mod673)]
c = Counter(li)
ans = 0
for v in list(c.values()):
ans += v * (v - 1) // 2
print(ans)
|
from collections import Counter
s = eval(input())
mod = 2019
li = [0]
num = 0
power = 1
for e in s[::-1]:
num += int(e) * power
num %= mod
li.append(num)
power *= 10
power %= mod
c = Counter(li)
ans = 0
for v in list(c.values()):
ans += v * (v - 1) // 2
print(ans)
| 33 | 21 | 529 | 301 |
from collections import Counter
def f(mod):
ret = [0]
power = 1
num = 0
for i, e in enumerate(s, 1):
num *= 10
num += int(e)
num %= mod
power *= 10
power %= mod
inv = pow(power, mod - 2, mod)
ret.append(num * inv % mod)
return ret
s = eval(input())
mod3 = f(3)
mod673 = f(673)
li = [10 * e673 + e3 for e3, e673 in zip(mod3, mod673)]
c = Counter(li)
ans = 0
for v in list(c.values()):
ans += v * (v - 1) // 2
print(ans)
|
from collections import Counter
s = eval(input())
mod = 2019
li = [0]
num = 0
power = 1
for e in s[::-1]:
num += int(e) * power
num %= mod
li.append(num)
power *= 10
power %= mod
c = Counter(li)
ans = 0
for v in list(c.values()):
ans += v * (v - 1) // 2
print(ans)
| false | 36.363636 |
[
"-",
"-def f(mod):",
"- ret = [0]",
"- power = 1",
"- num = 0",
"- for i, e in enumerate(s, 1):",
"- num *= 10",
"- num += int(e)",
"- num %= mod",
"- power *= 10",
"- power %= mod",
"- inv = pow(power, mod - 2, mod)",
"- ret.append(num * inv % mod)",
"- return ret",
"-",
"-",
"-mod3 = f(3)",
"-mod673 = f(673)",
"-li = [10 * e673 + e3 for e3, e673 in zip(mod3, mod673)]",
"+mod = 2019",
"+li = [0]",
"+num = 0",
"+power = 1",
"+for e in s[::-1]:",
"+ num += int(e) * power",
"+ num %= mod",
"+ li.append(num)",
"+ power *= 10",
"+ power %= mod"
] | false | 0.084789 | 0.04644 | 1.825796 |
[
"s846087139",
"s488633095"
] |
u936985471
|
p03420
|
python
|
s791664019
|
s526591739
| 103 | 89 | 3,064 | 3,060 |
Accepted
|
Accepted
| 13.59 |
N,K=list(map(int,input().split()))
if K==0:
print((N**2))
exit(0)
ans=0
for i in range(K+1,N+1):
cur=0
base=i-(K-1)-1
cur+=(N//i)*base
rest=N%i
cur+=max(rest-(K-1),0)
ans+=cur
print(ans)
|
N,K=list(map(int,input().split()))
if K==0:
print((N**2))
exit(0)
ans=0
for i in range(K+1,N+1):
base=i-(K-1)-1
ans+=(N//i)*base
rest=N%i
ans+=max(rest-(K-1),0)
print(ans)
| 13 | 11 | 206 | 185 |
N, K = list(map(int, input().split()))
if K == 0:
print((N**2))
exit(0)
ans = 0
for i in range(K + 1, N + 1):
cur = 0
base = i - (K - 1) - 1
cur += (N // i) * base
rest = N % i
cur += max(rest - (K - 1), 0)
ans += cur
print(ans)
|
N, K = list(map(int, input().split()))
if K == 0:
print((N**2))
exit(0)
ans = 0
for i in range(K + 1, N + 1):
base = i - (K - 1) - 1
ans += (N // i) * base
rest = N % i
ans += max(rest - (K - 1), 0)
print(ans)
| false | 15.384615 |
[
"- cur = 0",
"- cur += (N // i) * base",
"+ ans += (N // i) * base",
"- cur += max(rest - (K - 1), 0)",
"- ans += cur",
"+ ans += max(rest - (K - 1), 0)"
] | false | 0.043685 | 0.079176 | 0.551745 |
[
"s791664019",
"s526591739"
] |
u408314432
|
p02900
|
python
|
s439920489
|
s786184098
| 297 | 271 | 3,280 | 3,276 |
Accepted
|
Accepted
| 8.75 |
C,D = [int(e) for e in input().split()]
if C <= D:
m = D
n = C
else:
m = C
n = D
while n != 0 :
a = m%n
m = n
n = a
J = []
for i in range(1,int(m**0.5)+1):
if m % i == 0:
J.append(i)
if i != m//i:
J.append(m//i)
J.sort()
N = int(len(J))
M = [1]
I = []
for i in range(1,N):
for p in range(1,int(J[i]**0.5)+1):
if J[i]%p == 0:
I.extend([J[i]])
if int(len(I)) >=2:
break
if int(len(I)) == 1:
M.extend([J[i]])
I = []
M = int(len(M))
print(M)
|
C,D = [int(e) for e in input().split()]
if C <= D:
m = D
n = C
else:
m = C
n = D
while n != 0 :
a = m%n
m = n
n = a
J = []
for i in range(1,int(m**0.5)+1):
if m % i == 0:
J.append(i)
if i != m//i:
J.append(m//i)
J.sort()
N = int(len(J))
M = [1]
for i in range(1,N):
cnt = 0
for p in range(1,int(J[i]**0.5)+1):
if J[i]%p == 0:
cnt += 1
if cnt >=2:
break
if cnt == 1:
M.extend([J[i]])
M = int(len(M))
print(M)
| 43 | 42 | 619 | 588 |
C, D = [int(e) for e in input().split()]
if C <= D:
m = D
n = C
else:
m = C
n = D
while n != 0:
a = m % n
m = n
n = a
J = []
for i in range(1, int(m**0.5) + 1):
if m % i == 0:
J.append(i)
if i != m // i:
J.append(m // i)
J.sort()
N = int(len(J))
M = [1]
I = []
for i in range(1, N):
for p in range(1, int(J[i] ** 0.5) + 1):
if J[i] % p == 0:
I.extend([J[i]])
if int(len(I)) >= 2:
break
if int(len(I)) == 1:
M.extend([J[i]])
I = []
M = int(len(M))
print(M)
|
C, D = [int(e) for e in input().split()]
if C <= D:
m = D
n = C
else:
m = C
n = D
while n != 0:
a = m % n
m = n
n = a
J = []
for i in range(1, int(m**0.5) + 1):
if m % i == 0:
J.append(i)
if i != m // i:
J.append(m // i)
J.sort()
N = int(len(J))
M = [1]
for i in range(1, N):
cnt = 0
for p in range(1, int(J[i] ** 0.5) + 1):
if J[i] % p == 0:
cnt += 1
if cnt >= 2:
break
if cnt == 1:
M.extend([J[i]])
M = int(len(M))
print(M)
| false | 2.325581 |
[
"-I = []",
"+ cnt = 0",
"- I.extend([J[i]])",
"- if int(len(I)) >= 2:",
"+ cnt += 1",
"+ if cnt >= 2:",
"- if int(len(I)) == 1:",
"+ if cnt == 1:",
"- I = []"
] | false | 0.082045 | 0.035575 | 2.306259 |
[
"s439920489",
"s786184098"
] |
u813953440
|
p03478
|
python
|
s745117815
|
s433005460
| 39 | 32 | 3,444 | 2,940 |
Accepted
|
Accepted
| 17.95 |
N,A,B = list(map(int,input().split()))
C = [i for i in range(A,N+1)]
D = [i for i in range(A,10) if i <= B]
for c in C:
if c >= 10:
str_c = str(c)
len_c = len(str_c)
sum_c = 0
for i in range(len_c):
sum_c += int(str_c[i])
if A <= sum_c <= B:
D.append(c)
print((sum(D)))
|
N, A, B = list(map(int, input().split()))
res = 0
for i in range(N+1):
if A <= sum([int(s) for s in str(i)]) <= B:
res += i
print(res)
| 13 | 6 | 341 | 145 |
N, A, B = list(map(int, input().split()))
C = [i for i in range(A, N + 1)]
D = [i for i in range(A, 10) if i <= B]
for c in C:
if c >= 10:
str_c = str(c)
len_c = len(str_c)
sum_c = 0
for i in range(len_c):
sum_c += int(str_c[i])
if A <= sum_c <= B:
D.append(c)
print((sum(D)))
|
N, A, B = list(map(int, input().split()))
res = 0
for i in range(N + 1):
if A <= sum([int(s) for s in str(i)]) <= B:
res += i
print(res)
| false | 53.846154 |
[
"-C = [i for i in range(A, N + 1)]",
"-D = [i for i in range(A, 10) if i <= B]",
"-for c in C:",
"- if c >= 10:",
"- str_c = str(c)",
"- len_c = len(str_c)",
"- sum_c = 0",
"- for i in range(len_c):",
"- sum_c += int(str_c[i])",
"- if A <= sum_c <= B:",
"- D.append(c)",
"-print((sum(D)))",
"+res = 0",
"+for i in range(N + 1):",
"+ if A <= sum([int(s) for s in str(i)]) <= B:",
"+ res += i",
"+print(res)"
] | false | 0.053974 | 0.049975 | 1.080019 |
[
"s745117815",
"s433005460"
] |
u493520238
|
p03557
|
python
|
s939867428
|
s029590003
| 339 | 215 | 23,360 | 105,292 |
Accepted
|
Accepted
| 36.58 |
import bisect
n = int(eval(input()))
al = list(map(int,input().split()))
bl = list(map(int,input().split()))
cl = list(map(int,input().split()))
al.sort()
bl.sort()
cl.sort()
cnt = 0
for b in bl:
a_num = bisect.bisect_left(al,b)
c_num = n - bisect.bisect_right(cl,b)
cnt += a_num*c_num
# cnt += c_num
print(cnt)
|
import bisect
n = int(eval(input()))
al = list(map(int,input().split()))
bl = list(map(int,input().split()))
cl = list(map(int,input().split()))
al.sort()
bl.sort()
cl.sort()
ans = 0
for b in bl:
a_num = bisect.bisect_left(al,b)
c_num = n - bisect.bisect_right(cl,b)
ans += a_num*c_num
print(ans)
| 18 | 17 | 341 | 321 |
import bisect
n = int(eval(input()))
al = list(map(int, input().split()))
bl = list(map(int, input().split()))
cl = list(map(int, input().split()))
al.sort()
bl.sort()
cl.sort()
cnt = 0
for b in bl:
a_num = bisect.bisect_left(al, b)
c_num = n - bisect.bisect_right(cl, b)
cnt += a_num * c_num
# cnt += c_num
print(cnt)
|
import bisect
n = int(eval(input()))
al = list(map(int, input().split()))
bl = list(map(int, input().split()))
cl = list(map(int, input().split()))
al.sort()
bl.sort()
cl.sort()
ans = 0
for b in bl:
a_num = bisect.bisect_left(al, b)
c_num = n - bisect.bisect_right(cl, b)
ans += a_num * c_num
print(ans)
| false | 5.555556 |
[
"-cnt = 0",
"+ans = 0",
"- cnt += a_num * c_num",
"- # cnt += c_num",
"-print(cnt)",
"+ ans += a_num * c_num",
"+print(ans)"
] | false | 0.073198 | 0.053639 | 1.364627 |
[
"s939867428",
"s029590003"
] |
u077291787
|
p03014
|
python
|
s622609137
|
s267783696
| 1,010 | 594 | 318,736 | 177,032 |
Accepted
|
Accepted
| 41.19 |
# ABC129D - Lamp
import sys
input = sys.stdin.readline
def main():
H, W = tuple(map(int, input().split()))
S = tuple(input().rstrip() for _ in range(H))
L, R = [[0] * W for _ in range(H)], [[0] * W for _ in range(H)]
U, D = [[0] * W for _ in range(H)], [[0] * W for _ in range(H)]
for x1 in range(H):
for y1 in range(W):
if S[x1][y1] == ".": # left and upper sides of S[i][j]
U[x1][y1] = U[x1 - 1][y1] + 1
L[x1][y1] = L[x1][y1 - 1] + 1
x2, y2 = -x1 - 1, -y1 - 1
if S[x2][y2] == ".": # right and under sides
D[x2][y2] = D[x2 + 1][y2] + 1
R[x2][y2] = R[x2][y2 + 1] + 1
cand = [
L[i][j] + R[i][j] + U[i][j] + D[i][j] - 3 for i in range(H) for j in range(W)
]
ans = max(cand)
print(ans)
if __name__ == "__main__":
main()
|
# ABC129D - Lamp
import sys
input = sys.stdin.readline
def main():
H, W = tuple(map(int, input().split()))
S = tuple(input().rstrip() for _ in range(H))
L, R = [[0] * W for _ in range(H)], [[0] * W for _ in range(H)]
U, D = [[0] * W for _ in range(H)], [[0] * W for _ in range(H)]
for x1 in range(H):
for y1 in range(W):
if S[x1][y1] == ".": # left and upper sides of S[i][j]
U[x1][y1] = U[x1 - 1][y1] + 1
L[x1][y1] = L[x1][y1 - 1] + 1
x2, y2 = -x1 - 1, -y1 - 1
if S[x2][y2] == ".": # right and under sides
D[x2][y2] = D[x2 + 1][y2] + 1
R[x2][y2] = R[x2][y2 + 1] + 1
ans = -float("inf")
for i in range(H):
for j in range(W):
ans = max(ans, L[i][j] + R[i][j] + U[i][j] + D[i][j] - 3)
print(ans)
if __name__ == "__main__":
main()
| 27 | 27 | 903 | 922 |
# ABC129D - Lamp
import sys
input = sys.stdin.readline
def main():
H, W = tuple(map(int, input().split()))
S = tuple(input().rstrip() for _ in range(H))
L, R = [[0] * W for _ in range(H)], [[0] * W for _ in range(H)]
U, D = [[0] * W for _ in range(H)], [[0] * W for _ in range(H)]
for x1 in range(H):
for y1 in range(W):
if S[x1][y1] == ".": # left and upper sides of S[i][j]
U[x1][y1] = U[x1 - 1][y1] + 1
L[x1][y1] = L[x1][y1 - 1] + 1
x2, y2 = -x1 - 1, -y1 - 1
if S[x2][y2] == ".": # right and under sides
D[x2][y2] = D[x2 + 1][y2] + 1
R[x2][y2] = R[x2][y2 + 1] + 1
cand = [
L[i][j] + R[i][j] + U[i][j] + D[i][j] - 3 for i in range(H) for j in range(W)
]
ans = max(cand)
print(ans)
if __name__ == "__main__":
main()
|
# ABC129D - Lamp
import sys
input = sys.stdin.readline
def main():
H, W = tuple(map(int, input().split()))
S = tuple(input().rstrip() for _ in range(H))
L, R = [[0] * W for _ in range(H)], [[0] * W for _ in range(H)]
U, D = [[0] * W for _ in range(H)], [[0] * W for _ in range(H)]
for x1 in range(H):
for y1 in range(W):
if S[x1][y1] == ".": # left and upper sides of S[i][j]
U[x1][y1] = U[x1 - 1][y1] + 1
L[x1][y1] = L[x1][y1 - 1] + 1
x2, y2 = -x1 - 1, -y1 - 1
if S[x2][y2] == ".": # right and under sides
D[x2][y2] = D[x2 + 1][y2] + 1
R[x2][y2] = R[x2][y2 + 1] + 1
ans = -float("inf")
for i in range(H):
for j in range(W):
ans = max(ans, L[i][j] + R[i][j] + U[i][j] + D[i][j] - 3)
print(ans)
if __name__ == "__main__":
main()
| false | 0 |
[
"- cand = [",
"- L[i][j] + R[i][j] + U[i][j] + D[i][j] - 3 for i in range(H) for j in range(W)",
"- ]",
"- ans = max(cand)",
"+ ans = -float(\"inf\")",
"+ for i in range(H):",
"+ for j in range(W):",
"+ ans = max(ans, L[i][j] + R[i][j] + U[i][j] + D[i][j] - 3)"
] | false | 0.037587 | 0.033311 | 1.128395 |
[
"s622609137",
"s267783696"
] |
u489959379
|
p03329
|
python
|
s775122924
|
s253345522
| 580 | 372 | 6,296 | 3,864 |
Accepted
|
Accepted
| 35.86 |
n = int(eval(input()))
L = [1]
for i in range(1, 6):
L.append(pow(9, i))
for i in range(1, 7):
L.append(pow(6, i))
L = sorted(L)
dp = [float("inf") for _ in range(n + 1)]
dp[0] = 0
for i in range(1, n + 1):
for l in L:
if i - l >= 0:
dp[i] = min(dp[i], dp[i - l] + 1)
print((dp[n]))
|
import sys
sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n = int(eval(input()))
List = [1]
for i in range(1, 7):
List.append(pow(6, i))
List.append(pow(9, i))
List.sort()
dp = [f_inf for _ in range(n + 1)]
dp[0] = 0
for i in range(1, n + 1):
for L in List:
if i - L >= 0:
dp[i] = min(dp[i], dp[i - L] + 1)
print((dp[n]))
if __name__ == '__main__':
resolve()
| 14 | 29 | 320 | 514 |
n = int(eval(input()))
L = [1]
for i in range(1, 6):
L.append(pow(9, i))
for i in range(1, 7):
L.append(pow(6, i))
L = sorted(L)
dp = [float("inf") for _ in range(n + 1)]
dp[0] = 0
for i in range(1, n + 1):
for l in L:
if i - l >= 0:
dp[i] = min(dp[i], dp[i - l] + 1)
print((dp[n]))
|
import sys
sys.setrecursionlimit(10**7)
f_inf = float("inf")
mod = 10**9 + 7
def resolve():
n = int(eval(input()))
List = [1]
for i in range(1, 7):
List.append(pow(6, i))
List.append(pow(9, i))
List.sort()
dp = [f_inf for _ in range(n + 1)]
dp[0] = 0
for i in range(1, n + 1):
for L in List:
if i - L >= 0:
dp[i] = min(dp[i], dp[i - L] + 1)
print((dp[n]))
if __name__ == "__main__":
resolve()
| false | 51.724138 |
[
"-n = int(eval(input()))",
"-L = [1]",
"-for i in range(1, 6):",
"- L.append(pow(9, i))",
"-for i in range(1, 7):",
"- L.append(pow(6, i))",
"-L = sorted(L)",
"-dp = [float(\"inf\") for _ in range(n + 1)]",
"-dp[0] = 0",
"-for i in range(1, n + 1):",
"- for l in L:",
"- if i - l >= 0:",
"- dp[i] = min(dp[i], dp[i - l] + 1)",
"-print((dp[n]))",
"+import sys",
"+",
"+sys.setrecursionlimit(10**7)",
"+f_inf = float(\"inf\")",
"+mod = 10**9 + 7",
"+",
"+",
"+def resolve():",
"+ n = int(eval(input()))",
"+ List = [1]",
"+ for i in range(1, 7):",
"+ List.append(pow(6, i))",
"+ List.append(pow(9, i))",
"+ List.sort()",
"+ dp = [f_inf for _ in range(n + 1)]",
"+ dp[0] = 0",
"+ for i in range(1, n + 1):",
"+ for L in List:",
"+ if i - L >= 0:",
"+ dp[i] = min(dp[i], dp[i - L] + 1)",
"+ print((dp[n]))",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ resolve()"
] | false | 0.157333 | 0.080405 | 1.956765 |
[
"s775122924",
"s253345522"
] |
u779455925
|
p02793
|
python
|
s958093597
|
s254159930
| 911 | 461 | 67,416 | 70,616 |
Accepted
|
Accepted
| 49.4 |
from fractions import gcd
N=int(eval(input()))
A=list(map(int,input().split()))
mod=10**9+7
M=1
for a in A:
M=((M * a) // gcd(M, a))
M%=mod
count=0
for a in A:
count=(count+M*pow(a,mod-2,mod))%mod
print(count)
|
from collections import *
from itertools import *
from bisect import *
from heapq import *
import copy
import math
from fractions import gcd
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp //= i
arr.append([i, cnt])
if temp!=1:
arr.append([temp, 1])
if arr==[]:
arr.append([n, 1])
return arr
N=int(eval(input()))
A=list(map(int,input().split()))
mod=10**9+7
M=1
dic={}
for a in A:
Z=1
arr=factorization(a)
for b,c in arr:
if b in dic:
if c>dic[b]:
M=M*pow(b,c-dic[b],mod)%mod
dic[b]=c
else:
dic.update({b:c})
M=M*pow(b,c,mod)%mod
M%=mod
print((sum([M*pow(a,mod-2,mod)%mod for a in A])%mod))
| 14 | 48 | 227 | 932 |
from fractions import gcd
N = int(eval(input()))
A = list(map(int, input().split()))
mod = 10**9 + 7
M = 1
for a in A:
M = (M * a) // gcd(M, a)
M %= mod
count = 0
for a in A:
count = (count + M * pow(a, mod - 2, mod)) % mod
print(count)
|
from collections import *
from itertools import *
from bisect import *
from heapq import *
import copy
import math
from fractions import gcd
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-(n**0.5) // 1)) + 1):
if temp % i == 0:
cnt = 0
while temp % i == 0:
cnt += 1
temp //= i
arr.append([i, cnt])
if temp != 1:
arr.append([temp, 1])
if arr == []:
arr.append([n, 1])
return arr
N = int(eval(input()))
A = list(map(int, input().split()))
mod = 10**9 + 7
M = 1
dic = {}
for a in A:
Z = 1
arr = factorization(a)
for b, c in arr:
if b in dic:
if c > dic[b]:
M = M * pow(b, c - dic[b], mod) % mod
dic[b] = c
else:
dic.update({b: c})
M = M * pow(b, c, mod) % mod
M %= mod
print((sum([M * pow(a, mod - 2, mod) % mod for a in A]) % mod))
| false | 70.833333 |
[
"+from collections import *",
"+from itertools import *",
"+from bisect import *",
"+from heapq import *",
"+import copy",
"+import math",
"+",
"+",
"+def factorization(n):",
"+ arr = []",
"+ temp = n",
"+ for i in range(2, int(-(-(n**0.5) // 1)) + 1):",
"+ if temp % i == 0:",
"+ cnt = 0",
"+ while temp % i == 0:",
"+ cnt += 1",
"+ temp //= i",
"+ arr.append([i, cnt])",
"+ if temp != 1:",
"+ arr.append([temp, 1])",
"+ if arr == []:",
"+ arr.append([n, 1])",
"+ return arr",
"+",
"+dic = {}",
"- M = (M * a) // gcd(M, a)",
"+ Z = 1",
"+ arr = factorization(a)",
"+ for b, c in arr:",
"+ if b in dic:",
"+ if c > dic[b]:",
"+ M = M * pow(b, c - dic[b], mod) % mod",
"+ dic[b] = c",
"+ else:",
"+ dic.update({b: c})",
"+ M = M * pow(b, c, mod) % mod",
"-count = 0",
"-for a in A:",
"- count = (count + M * pow(a, mod - 2, mod)) % mod",
"-print(count)",
"+print((sum([M * pow(a, mod - 2, mod) % mod for a in A]) % mod))"
] | false | 0.053292 | 0.037455 | 1.422817 |
[
"s958093597",
"s254159930"
] |
u925626880
|
p03448
|
python
|
s302950411
|
s726194290
| 53 | 45 | 3,060 | 3,060 |
Accepted
|
Accepted
| 15.09 |
# -*- coding: utf-8 -*-
a = int(eval(input())) # 500
b = int(eval(input())) # 100
c = int(eval(input())) # 50
x = int(eval(input()))
ans = 0
for i in range(a + 1):
for j in range(b + 1):
for k in range(c + 1):
if 500 * i + 100 * j + 50 * k == x:
ans += 1
print(ans)
|
a = int(eval(input())) # 500
b = int(eval(input())) # 100
c = int(eval(input())) # 50
x = int(eval(input()))
ans = 0
for i in range(a+1):
I = i*500
for j in range(b+1):
J = j*100
for k in range(c+1):
K = k*50
if I+J+K == x:
ans +=1
print(ans)
| 16 | 17 | 301 | 303 |
# -*- coding: utf-8 -*-
a = int(eval(input())) # 500
b = int(eval(input())) # 100
c = int(eval(input())) # 50
x = int(eval(input()))
ans = 0
for i in range(a + 1):
for j in range(b + 1):
for k in range(c + 1):
if 500 * i + 100 * j + 50 * k == x:
ans += 1
print(ans)
|
a = int(eval(input())) # 500
b = int(eval(input())) # 100
c = int(eval(input())) # 50
x = int(eval(input()))
ans = 0
for i in range(a + 1):
I = i * 500
for j in range(b + 1):
J = j * 100
for k in range(c + 1):
K = k * 50
if I + J + K == x:
ans += 1
print(ans)
| false | 5.882353 |
[
"-# -*- coding: utf-8 -*-",
"-c = int(eval(input())) # 50",
"+c = int(eval(input())) # 50",
"+ I = i * 500",
"+ J = j * 100",
"- if 500 * i + 100 * j + 50 * k == x:",
"+ K = k * 50",
"+ if I + J + K == x:"
] | false | 0.0708 | 0.110822 | 0.638863 |
[
"s302950411",
"s726194290"
] |
u499381410
|
p04045
|
python
|
s218677840
|
s649003468
| 280 | 258 | 41,964 | 42,220 |
Accepted
|
Accepted
| 7.86 |
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
from pprint import pprint
from copy import deepcopy
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce
from pprint import pprint
sys.setrecursionlimit(2147483647)
INF = 10 ** 13
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 = 1000000007
n, k = LI()
D = set(range(10)) - set(LI())
for i in range(n, 100000):
if set([int(j) for j in str(i)]) <= D:
print(i)
break
|
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
from pprint import pprint
from copy import deepcopy
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce
from pprint import pprint
sys.setrecursionlimit(2147483647)
INF = 10 ** 13
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 = 1000000007
n, k = LI()
D = set(LI())
for i in range(n, 100000):
if not set([int(j) for j in str(i)]) & D:
print(i)
break
| 43 | 43 | 1,264 | 1,250 |
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
from pprint import pprint
from copy import deepcopy
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce
from pprint import pprint
sys.setrecursionlimit(2147483647)
INF = 10**13
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 = 1000000007
n, k = LI()
D = set(range(10)) - set(LI())
for i in range(n, 100000):
if set([int(j) for j in str(i)]) <= D:
print(i)
break
|
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
from pprint import pprint
from copy import deepcopy
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce
from pprint import pprint
sys.setrecursionlimit(2147483647)
INF = 10**13
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 = 1000000007
n, k = LI()
D = set(LI())
for i in range(n, 100000):
if not set([int(j) for j in str(i)]) & D:
print(i)
break
| false | 0 |
[
"-D = set(range(10)) - set(LI())",
"+D = set(LI())",
"- if set([int(j) for j in str(i)]) <= D:",
"+ if not set([int(j) for j in str(i)]) & D:"
] | false | 0.09428 | 0.049769 | 1.894343 |
[
"s218677840",
"s649003468"
] |
u247830763
|
p03163
|
python
|
s118768649
|
s544615750
| 936 | 321 | 305,244 | 150,200 |
Accepted
|
Accepted
| 65.71 |
n,w = list(map(int,input().split()))
inf = float("inf")
dp = [[-inf]*(w+1) for _ in range(n+1)]
for j in range(w+1):
dp[0][j] = 0
for i in range(n):
s,t = list(map(int,input().split()))
for l in range(w+1):
if l-s >=0:
dp[i+1][l] = max(dp[i][l],dp[i][l-s]+t)
else:
dp[i+1][l] = dp[i][l]
print((dp[-1][w]))
|
n,w = list(map(int,input().split()))
ls = [list(map(int,input().split())) for _ in range(n)]
dp = [[0]*(w+1) for _ in range(n+1)]
for i in range(n):
for p in range(w+1):
if p >= ls[i][0]:
dp[i+1][p] = max(dp[i][p],dp[i][p-ls[i][0]]+ls[i][1])
else:
dp[i+1][p] = dp[i][p]
print((dp[n][w]))
| 13 | 10 | 363 | 332 |
n, w = list(map(int, input().split()))
inf = float("inf")
dp = [[-inf] * (w + 1) for _ in range(n + 1)]
for j in range(w + 1):
dp[0][j] = 0
for i in range(n):
s, t = list(map(int, input().split()))
for l in range(w + 1):
if l - s >= 0:
dp[i + 1][l] = max(dp[i][l], dp[i][l - s] + t)
else:
dp[i + 1][l] = dp[i][l]
print((dp[-1][w]))
|
n, w = list(map(int, input().split()))
ls = [list(map(int, input().split())) for _ in range(n)]
dp = [[0] * (w + 1) for _ in range(n + 1)]
for i in range(n):
for p in range(w + 1):
if p >= ls[i][0]:
dp[i + 1][p] = max(dp[i][p], dp[i][p - ls[i][0]] + ls[i][1])
else:
dp[i + 1][p] = dp[i][p]
print((dp[n][w]))
| false | 23.076923 |
[
"-inf = float(\"inf\")",
"-dp = [[-inf] * (w + 1) for _ in range(n + 1)]",
"-for j in range(w + 1):",
"- dp[0][j] = 0",
"+ls = [list(map(int, input().split())) for _ in range(n)]",
"+dp = [[0] * (w + 1) for _ in range(n + 1)]",
"- s, t = list(map(int, input().split()))",
"- for l in range(w + 1):",
"- if l - s >= 0:",
"- dp[i + 1][l] = max(dp[i][l], dp[i][l - s] + t)",
"+ for p in range(w + 1):",
"+ if p >= ls[i][0]:",
"+ dp[i + 1][p] = max(dp[i][p], dp[i][p - ls[i][0]] + ls[i][1])",
"- dp[i + 1][l] = dp[i][l]",
"-print((dp[-1][w]))",
"+ dp[i + 1][p] = dp[i][p]",
"+print((dp[n][w]))"
] | false | 0.038783 | 0.054806 | 0.707634 |
[
"s118768649",
"s544615750"
] |
u073549161
|
p03408
|
python
|
s485650408
|
s624989474
| 168 | 17 | 38,256 | 3,064 |
Accepted
|
Accepted
| 89.88 |
ad = {}
mi = {}
n = int(eval(input()))
for i in range(n):
s = eval(input())
n = ad.get(s, 0)
n += 1
ad[s] = n
n = int(eval(input()))
for i in range(n):
s = eval(input())
n = mi.get(s, 0)
n += 1
mi[s] = n
res = 0
for k in list(ad.keys()):
val = ad[k]
val -= mi.get(k, 0)
res = max(res, val)
print(res)
|
d = {}
n = int(eval(input()))
for i in range(n):
s = eval(input())
c = d.get(s, 0)
d[s] = c + 1
m = int(eval(input()))
for i in range(m):
s = eval(input())
c = d.get(s, 0)
d[s] = c - 1
co = 0
wo = ""
for k in d:
if d[k] > co:
co = d[k]
wo = k
print((co if co > 0 else "0"))
| 24 | 18 | 341 | 308 |
ad = {}
mi = {}
n = int(eval(input()))
for i in range(n):
s = eval(input())
n = ad.get(s, 0)
n += 1
ad[s] = n
n = int(eval(input()))
for i in range(n):
s = eval(input())
n = mi.get(s, 0)
n += 1
mi[s] = n
res = 0
for k in list(ad.keys()):
val = ad[k]
val -= mi.get(k, 0)
res = max(res, val)
print(res)
|
d = {}
n = int(eval(input()))
for i in range(n):
s = eval(input())
c = d.get(s, 0)
d[s] = c + 1
m = int(eval(input()))
for i in range(m):
s = eval(input())
c = d.get(s, 0)
d[s] = c - 1
co = 0
wo = ""
for k in d:
if d[k] > co:
co = d[k]
wo = k
print((co if co > 0 else "0"))
| false | 25 |
[
"-ad = {}",
"-mi = {}",
"+d = {}",
"- n = ad.get(s, 0)",
"- n += 1",
"- ad[s] = n",
"-n = int(eval(input()))",
"-for i in range(n):",
"+ c = d.get(s, 0)",
"+ d[s] = c + 1",
"+m = int(eval(input()))",
"+for i in range(m):",
"- n = mi.get(s, 0)",
"- n += 1",
"- mi[s] = n",
"-res = 0",
"-for k in list(ad.keys()):",
"- val = ad[k]",
"- val -= mi.get(k, 0)",
"- res = max(res, val)",
"-print(res)",
"+ c = d.get(s, 0)",
"+ d[s] = c - 1",
"+co = 0",
"+wo = \"\"",
"+for k in d:",
"+ if d[k] > co:",
"+ co = d[k]",
"+ wo = k",
"+print((co if co > 0 else \"0\"))"
] | false | 0.046988 | 0.043321 | 1.084644 |
[
"s485650408",
"s624989474"
] |
u644907318
|
p02778
|
python
|
s148854262
|
s655503936
| 180 | 69 | 38,384 | 61,624 |
Accepted
|
Accepted
| 61.67 |
S = input().strip()
n = len(S)
print(("x"*n))
|
S = input().strip()
print(("x"*len(S)))
| 3 | 2 | 45 | 38 |
S = input().strip()
n = len(S)
print(("x" * n))
|
S = input().strip()
print(("x" * len(S)))
| false | 33.333333 |
[
"-n = len(S)",
"-print((\"x\" * n))",
"+print((\"x\" * len(S)))"
] | false | 0.142054 | 0.05501 | 2.582327 |
[
"s148854262",
"s655503936"
] |
u785578220
|
p03032
|
python
|
s808080482
|
s444132126
| 36 | 31 | 3,064 | 3,064 |
Accepted
|
Accepted
| 13.89 |
import heapq
N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
m = min(N,K) #KがNより大きい場合を防ぐ
M = 0
for i in range(m+1):
for j in range(m-i+1):
A1 = A[:i] #前から取る
A3 = A[N-j:] #後ろから取る
new_A = A1+A3
new_A.sort(reverse=True)
h = K - len(new_A)
while h >0 and new_A:
if new_A[-1] > 0:
break
else:
new_A.pop()
h-=1
M = max(M,sum(new_A))
print(M)
|
N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
m = min(N,K)
M = 0
for i in range(m+1):
for j in range(m-i+1):
v=A[:i]+A[N-j:]
v.sort()
v=v[::-1]
h=K-len(v)
while h >0 and v:
if v[-1] > 0:
break
else:
v.pop()
h-=1
M=max(M,sum(v))
print(M)
| 20 | 18 | 506 | 398 |
import heapq
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
m = min(N, K) # KがNより大きい場合を防ぐ
M = 0
for i in range(m + 1):
for j in range(m - i + 1):
A1 = A[:i] # 前から取る
A3 = A[N - j :] # 後ろから取る
new_A = A1 + A3
new_A.sort(reverse=True)
h = K - len(new_A)
while h > 0 and new_A:
if new_A[-1] > 0:
break
else:
new_A.pop()
h -= 1
M = max(M, sum(new_A))
print(M)
|
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
m = min(N, K)
M = 0
for i in range(m + 1):
for j in range(m - i + 1):
v = A[:i] + A[N - j :]
v.sort()
v = v[::-1]
h = K - len(v)
while h > 0 and v:
if v[-1] > 0:
break
else:
v.pop()
h -= 1
M = max(M, sum(v))
print(M)
| false | 10 |
[
"-import heapq",
"-",
"-m = min(N, K) # KがNより大きい場合を防ぐ",
"+m = min(N, K)",
"- A1 = A[:i] # 前から取る",
"- A3 = A[N - j :] # 後ろから取る",
"- new_A = A1 + A3",
"- new_A.sort(reverse=True)",
"- h = K - len(new_A)",
"- while h > 0 and new_A:",
"- if new_A[-1] > 0:",
"+ v = A[:i] + A[N - j :]",
"+ v.sort()",
"+ v = v[::-1]",
"+ h = K - len(v)",
"+ while h > 0 and v:",
"+ if v[-1] > 0:",
"- new_A.pop()",
"+ v.pop()",
"- M = max(M, sum(new_A))",
"+ M = max(M, sum(v))"
] | false | 0.046904 | 0.046794 | 1.002342 |
[
"s808080482",
"s444132126"
] |
u556594202
|
p03478
|
python
|
s057299295
|
s522480154
| 45 | 32 | 8,956 | 8,948 |
Accepted
|
Accepted
| 28.89 |
N,A,B=input().split()
sum=0
for i in range(int(N)+1):
nums = list(str(i))
tmp = 0
for j in nums:
tmp = tmp + int(j)
if int(A)<=tmp:
if tmp<=int(B):
sum = sum + i
print(sum)
|
N,A,B=input().split()
N=int(N)
A=int(A)
B=int(B)
def findSumOfDigits(n):
k = 0
sum = 0
while n>0:
k = n%10
n = n//10
sum = sum + k
return sum
sum=0
for i in range(N+1):
tmp = findSumOfDigits(i)
if A<=tmp:
if tmp<=B:
sum = sum + i
print(sum)
| 12 | 21 | 229 | 331 |
N, A, B = input().split()
sum = 0
for i in range(int(N) + 1):
nums = list(str(i))
tmp = 0
for j in nums:
tmp = tmp + int(j)
if int(A) <= tmp:
if tmp <= int(B):
sum = sum + i
print(sum)
|
N, A, B = input().split()
N = int(N)
A = int(A)
B = int(B)
def findSumOfDigits(n):
k = 0
sum = 0
while n > 0:
k = n % 10
n = n // 10
sum = sum + k
return sum
sum = 0
for i in range(N + 1):
tmp = findSumOfDigits(i)
if A <= tmp:
if tmp <= B:
sum = sum + i
print(sum)
| false | 42.857143 |
[
"+N = int(N)",
"+A = int(A)",
"+B = int(B)",
"+",
"+",
"+def findSumOfDigits(n):",
"+ k = 0",
"+ sum = 0",
"+ while n > 0:",
"+ k = n % 10",
"+ n = n // 10",
"+ sum = sum + k",
"+ return sum",
"+",
"+",
"-for i in range(int(N) + 1):",
"- nums = list(str(i))",
"- tmp = 0",
"- for j in nums:",
"- tmp = tmp + int(j)",
"- if int(A) <= tmp:",
"- if tmp <= int(B):",
"+for i in range(N + 1):",
"+ tmp = findSumOfDigits(i)",
"+ if A <= tmp:",
"+ if tmp <= B:"
] | false | 0.037841 | 0.036543 | 1.035519 |
[
"s057299295",
"s522480154"
] |
u941753895
|
p03569
|
python
|
s886538569
|
s832307684
| 99 | 56 | 5,960 | 10,752 |
Accepted
|
Accepted
| 43.43 |
import math,itertools,fractions,heapq,collections,bisect,sys,queue,copy
sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return eval(input())
def main():
s=S()
q=collections.deque(s)
ans=0
while len(q)>1:
if q[0]==q[-1]:
q.popleft()
q.pop()
else:
if q[0]=='x':
q.append('x')
elif q[-1]=='x':
q.appendleft('x')
else:
return -1
ans+=1
return ans
# main()
print((main()))
|
import math,itertools,fractions,heapq,collections,bisect,sys,queue,copy
sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
# def LF(): return [float(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return eval(input())
def main():
s=S()
l=0
r=len(s)-1
ans=0
while l<r:
if s[l]=='x':
if s[r]=='x':
l+=1
r-=1
else:
l+=1
ans+=1
else:
if s[r]=='x':
r-=1
ans+=1
else:
if s[l]==s[r]:
l+=1
r-=1
else:
return -1
return ans
# main()
print((main()))
| 38 | 44 | 850 | 909 |
import math, itertools, fractions, heapq, collections, bisect, sys, queue, copy
sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def LF():
return [float(x) for x in sys.stdin.readline().split()]
def I():
return int(sys.stdin.readline())
def F():
return float(sys.stdin.readline())
def LS():
return sys.stdin.readline().split()
def S():
return eval(input())
def main():
s = S()
q = collections.deque(s)
ans = 0
while len(q) > 1:
if q[0] == q[-1]:
q.popleft()
q.pop()
else:
if q[0] == "x":
q.append("x")
elif q[-1] == "x":
q.appendleft("x")
else:
return -1
ans += 1
return ans
# main()
print((main()))
|
import math, itertools, fractions, heapq, collections, bisect, sys, queue, copy
sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]
def LI():
return [int(x) for x in sys.stdin.readline().split()]
# def LF(): return [float(x) for x in sys.stdin.readline().split()]
def I():
return int(sys.stdin.readline())
def F():
return float(sys.stdin.readline())
def LS():
return sys.stdin.readline().split()
def S():
return eval(input())
def main():
s = S()
l = 0
r = len(s) - 1
ans = 0
while l < r:
if s[l] == "x":
if s[r] == "x":
l += 1
r -= 1
else:
l += 1
ans += 1
else:
if s[r] == "x":
r -= 1
ans += 1
else:
if s[l] == s[r]:
l += 1
r -= 1
else:
return -1
return ans
# main()
print((main()))
| false | 13.636364 |
[
"-def LF():",
"- return [float(x) for x in sys.stdin.readline().split()]",
"-",
"-",
"+# def LF(): return [float(x) for x in sys.stdin.readline().split()]",
"- q = collections.deque(s)",
"+ l = 0",
"+ r = len(s) - 1",
"- while len(q) > 1:",
"- if q[0] == q[-1]:",
"- q.popleft()",
"- q.pop()",
"+ while l < r:",
"+ if s[l] == \"x\":",
"+ if s[r] == \"x\":",
"+ l += 1",
"+ r -= 1",
"+ else:",
"+ l += 1",
"+ ans += 1",
"- if q[0] == \"x\":",
"- q.append(\"x\")",
"- elif q[-1] == \"x\":",
"- q.appendleft(\"x\")",
"+ if s[r] == \"x\":",
"+ r -= 1",
"+ ans += 1",
"- return -1",
"- ans += 1",
"+ if s[l] == s[r]:",
"+ l += 1",
"+ r -= 1",
"+ else:",
"+ return -1"
] | false | 0.108608 | 0.03884 | 2.796309 |
[
"s886538569",
"s832307684"
] |
u397496203
|
p02735
|
python
|
s453150623
|
s116911163
| 201 | 92 | 95,364 | 73,620 |
Accepted
|
Accepted
| 54.23 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
H,W = list(map(int,readline().split()))
S = ''.join(read().decode().split())
INF = 10 ** 9
N = H*W
U = 250
dp = [[INF] * U for _ in range(N)]
# そのマスをいじる回数 → 総回数の最小値
dp[0] = list(range(U))
for n in range(H*W):
for i in range(U-1,0,-1):
if dp[n][i-1]> dp[n][i]:
dp[n][i-1] = dp[n][i]
for i in range(1,U):
if dp[n][i-1] + 1 < dp[n][i]:
dp[n][i] = dp[n][i-1] + 1
s = S[n]
if s == '#':
for i in range(0,U,2):
dp[n][i] = INF
else:
for i in range(1,U,2):
dp[n][i] = INF
x,y = divmod(n,W)
to = []
if y < W - 1:
to.append(n+1)
if x < H - 1:
to.append(n+W)
for m in to:
for i in range(U):
if dp[m][i] > dp[n][i]:
dp[m][i] = dp[n][i]
print((min(dp[-1])))
|
# https://atcoder.jp/contests/agc043/tasks/agc043_a
import sys
# sys.setrecursionlimit(100000)
def input():
return sys.stdin.readline().strip()
def input_int():
return int(eval(input()))
def input_int_list():
return [int(i) for i in input().split()]
ans = (100 * 100) + 1
def main():
global ans
h, w = input_int_list()
grid = []
grid.append(["#"] * (w + 2))
for _ in range(h):
grid.append(["#"] + list(eval(input())) + ["#"])
grid.append(["#"] * (w + 2))
dp = [[101 for _ in range(w + 2)] for _ in range(h + 2)]
if grid[1][1] == "#":
dp[1][1] = 1
else:
dp[1][1] = 0
for i in range(1, h + 1):
for j in range(1, w + 1):
# 上のマスからくる場合を評価
if i > 1:
if grid[i - 1][j] == "." and grid[i][j] == "#":
dp[i][j] = min(dp[i - 1][j] + 1, dp[i][j])
else:
dp[i][j] = min(dp[i][j], dp[i - 1][j])
# 左のマスからくる場合を評価
if j > 1:
if grid[i][j - 1] == "." and grid[i][j] == "#":
dp[i][j] = min(dp[i][j - 1] + 1, dp[i][j])
else:
dp[i][j] = min(dp[i][j - 1], dp[i][j])
print((dp[h][w]))
return
if __name__ == "__main__":
main()
| 40 | 57 | 968 | 1,347 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
H, W = list(map(int, readline().split()))
S = "".join(read().decode().split())
INF = 10**9
N = H * W
U = 250
dp = [[INF] * U for _ in range(N)]
# そのマスをいじる回数 → 総回数の最小値
dp[0] = list(range(U))
for n in range(H * W):
for i in range(U - 1, 0, -1):
if dp[n][i - 1] > dp[n][i]:
dp[n][i - 1] = dp[n][i]
for i in range(1, U):
if dp[n][i - 1] + 1 < dp[n][i]:
dp[n][i] = dp[n][i - 1] + 1
s = S[n]
if s == "#":
for i in range(0, U, 2):
dp[n][i] = INF
else:
for i in range(1, U, 2):
dp[n][i] = INF
x, y = divmod(n, W)
to = []
if y < W - 1:
to.append(n + 1)
if x < H - 1:
to.append(n + W)
for m in to:
for i in range(U):
if dp[m][i] > dp[n][i]:
dp[m][i] = dp[n][i]
print((min(dp[-1])))
|
# https://atcoder.jp/contests/agc043/tasks/agc043_a
import sys
# sys.setrecursionlimit(100000)
def input():
return sys.stdin.readline().strip()
def input_int():
return int(eval(input()))
def input_int_list():
return [int(i) for i in input().split()]
ans = (100 * 100) + 1
def main():
global ans
h, w = input_int_list()
grid = []
grid.append(["#"] * (w + 2))
for _ in range(h):
grid.append(["#"] + list(eval(input())) + ["#"])
grid.append(["#"] * (w + 2))
dp = [[101 for _ in range(w + 2)] for _ in range(h + 2)]
if grid[1][1] == "#":
dp[1][1] = 1
else:
dp[1][1] = 0
for i in range(1, h + 1):
for j in range(1, w + 1):
# 上のマスからくる場合を評価
if i > 1:
if grid[i - 1][j] == "." and grid[i][j] == "#":
dp[i][j] = min(dp[i - 1][j] + 1, dp[i][j])
else:
dp[i][j] = min(dp[i][j], dp[i - 1][j])
# 左のマスからくる場合を評価
if j > 1:
if grid[i][j - 1] == "." and grid[i][j] == "#":
dp[i][j] = min(dp[i][j - 1] + 1, dp[i][j])
else:
dp[i][j] = min(dp[i][j - 1], dp[i][j])
print((dp[h][w]))
return
if __name__ == "__main__":
main()
| false | 29.824561 |
[
"+# https://atcoder.jp/contests/agc043/tasks/agc043_a",
"-read = sys.stdin.buffer.read",
"-readline = sys.stdin.buffer.readline",
"-readlines = sys.stdin.buffer.readlines",
"-H, W = list(map(int, readline().split()))",
"-S = \"\".join(read().decode().split())",
"-INF = 10**9",
"-N = H * W",
"-U = 250",
"-dp = [[INF] * U for _ in range(N)]",
"-# そのマスをいじる回数 → 総回数の最小値",
"-dp[0] = list(range(U))",
"-for n in range(H * W):",
"- for i in range(U - 1, 0, -1):",
"- if dp[n][i - 1] > dp[n][i]:",
"- dp[n][i - 1] = dp[n][i]",
"- for i in range(1, U):",
"- if dp[n][i - 1] + 1 < dp[n][i]:",
"- dp[n][i] = dp[n][i - 1] + 1",
"- s = S[n]",
"- if s == \"#\":",
"- for i in range(0, U, 2):",
"- dp[n][i] = INF",
"+# sys.setrecursionlimit(100000)",
"+def input():",
"+ return sys.stdin.readline().strip()",
"+",
"+",
"+def input_int():",
"+ return int(eval(input()))",
"+",
"+",
"+def input_int_list():",
"+ return [int(i) for i in input().split()]",
"+",
"+",
"+ans = (100 * 100) + 1",
"+",
"+",
"+def main():",
"+ global ans",
"+ h, w = input_int_list()",
"+ grid = []",
"+ grid.append([\"#\"] * (w + 2))",
"+ for _ in range(h):",
"+ grid.append([\"#\"] + list(eval(input())) + [\"#\"])",
"+ grid.append([\"#\"] * (w + 2))",
"+ dp = [[101 for _ in range(w + 2)] for _ in range(h + 2)]",
"+ if grid[1][1] == \"#\":",
"+ dp[1][1] = 1",
"- for i in range(1, U, 2):",
"- dp[n][i] = INF",
"- x, y = divmod(n, W)",
"- to = []",
"- if y < W - 1:",
"- to.append(n + 1)",
"- if x < H - 1:",
"- to.append(n + W)",
"- for m in to:",
"- for i in range(U):",
"- if dp[m][i] > dp[n][i]:",
"- dp[m][i] = dp[n][i]",
"-print((min(dp[-1])))",
"+ dp[1][1] = 0",
"+ for i in range(1, h + 1):",
"+ for j in range(1, w + 1):",
"+ # 上のマスからくる場合を評価",
"+ if i > 1:",
"+ if grid[i - 1][j] == \".\" and grid[i][j] == \"#\":",
"+ dp[i][j] = min(dp[i - 1][j] + 1, dp[i][j])",
"+ else:",
"+ dp[i][j] = min(dp[i][j], dp[i - 1][j])",
"+ # 左のマスからくる場合を評価",
"+ if j > 1:",
"+ if grid[i][j - 1] == \".\" and grid[i][j] == \"#\":",
"+ dp[i][j] = min(dp[i][j - 1] + 1, dp[i][j])",
"+ else:",
"+ dp[i][j] = min(dp[i][j - 1], dp[i][j])",
"+ print((dp[h][w]))",
"+ return",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false | 0.075895 | 0.037267 | 2.036557 |
[
"s453150623",
"s116911163"
] |
u912237403
|
p00042
|
python
|
s995279965
|
s348883445
| 610 | 500 | 4,360 | 4,336 |
Accepted
|
Accepted
| 18.03 |
count =0
while True:
W = eval(input())
if (W==0): break
work={0:0}
count +=1
N = eval(input())
for i in range(N):
p,w = eval(input())
for w0 in sorted(list(work.keys()),reverse=True):
w1 = w0+w
p1 = work[w0]+p
if w1>W or (w1 in work and work[w1]>=p1): continue
else: work[w1] = p1
m = max(work.values())
tmp = list(work.values()).index(m)
n = list(work.keys())[tmp]
print("Case %d:" %(count))
print(m)
print(n)
|
count =0
while True:
W = eval(input())
if W==0: break
work = [0]*1001
count +=1
N = eval(input())
m = 0
n = 0
for i in range(N):
p,w = eval(input())
for w0 in range(W+1)[::-1]:
p0 = work[w0]
if w0>0 and p0==0: continue
w1 = w0+w
p1 = p0+p
if w1<=W and work[w1]<p1:
work[w1] = p1
if m<p1:
m = p1
n = work.index(m)
print("Case {}:".format(count))
print(m)
print(n)
| 21 | 24 | 510 | 540 |
count = 0
while True:
W = eval(input())
if W == 0:
break
work = {0: 0}
count += 1
N = eval(input())
for i in range(N):
p, w = eval(input())
for w0 in sorted(list(work.keys()), reverse=True):
w1 = w0 + w
p1 = work[w0] + p
if w1 > W or (w1 in work and work[w1] >= p1):
continue
else:
work[w1] = p1
m = max(work.values())
tmp = list(work.values()).index(m)
n = list(work.keys())[tmp]
print("Case %d:" % (count))
print(m)
print(n)
|
count = 0
while True:
W = eval(input())
if W == 0:
break
work = [0] * 1001
count += 1
N = eval(input())
m = 0
n = 0
for i in range(N):
p, w = eval(input())
for w0 in range(W + 1)[::-1]:
p0 = work[w0]
if w0 > 0 and p0 == 0:
continue
w1 = w0 + w
p1 = p0 + p
if w1 <= W and work[w1] < p1:
work[w1] = p1
if m < p1:
m = p1
n = work.index(m)
print("Case {}:".format(count))
print(m)
print(n)
| false | 12.5 |
[
"- work = {0: 0}",
"+ work = [0] * 1001",
"+ m = 0",
"+ n = 0",
"- for w0 in sorted(list(work.keys()), reverse=True):",
"+ for w0 in range(W + 1)[::-1]:",
"+ p0 = work[w0]",
"+ if w0 > 0 and p0 == 0:",
"+ continue",
"- p1 = work[w0] + p",
"- if w1 > W or (w1 in work and work[w1] >= p1):",
"- continue",
"- else:",
"+ p1 = p0 + p",
"+ if w1 <= W and work[w1] < p1:",
"- m = max(work.values())",
"- tmp = list(work.values()).index(m)",
"- n = list(work.keys())[tmp]",
"- print(\"Case %d:\" % (count))",
"+ if m < p1:",
"+ m = p1",
"+ n = work.index(m)",
"+ print(\"Case {}:\".format(count))"
] | false | 0.092405 | 0.162028 | 0.570303 |
[
"s995279965",
"s348883445"
] |
u600402037
|
p02990
|
python
|
s958355831
|
s579426240
| 287 | 172 | 21,644 | 12,752 |
Accepted
|
Accepted
| 40.07 |
import sys
import numpy as np
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
def cmb(n, k):
if n < k: return 0
return fact[n] * fact_inv[k] % MOD * fact_inv[n-k] % MOD
def cumprod(arr, MOD):
L = len(arr); Lsq = int(L**.5+1)
arr = np.resize(arr, Lsq**2).reshape(Lsq, Lsq)
for n in range(1, Lsq):
arr[:, n] *= arr[:, n-1]; arr[:, n] %= MOD
for n in range(1, Lsq):
arr[n] *= arr[n-1, -1]; arr[n] %= MOD
return arr.ravel()[:L]
def make_fact(U, MOD):
x = np.arange(U, dtype=np.int64); x[0] = 1
fact = cumprod(x, MOD)
x = np.arange(U, 0, -1, dtype=np.int64); x[0] = pow(int(fact[-1]), MOD-2, MOD)
fact_inv = cumprod(x, MOD)[::-1]
return fact, fact_inv
N, K = lr()
MOD = 10 ** 9 + 7
U = 2010 # 階乗テーブルの上限
fact, fact_inv = make_fact(U, MOD)
red = N-K
for i in range(1, K+1):
# (red+1)Ci
answer = cmb(red+1, i)
#print(answer)
remain = K - i
# remainをiの中に自由にいれる、i-1の壁を用意
# (remain+(i-1)) C remain
answer *= cmb(remain+i-1, remain)
print((answer%MOD))
# 15
|
import sys
import numpy as np
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
MOD = 10 ** 9 + 7
N, K = lr()
def cmb(n, k):
if k < 0 or k > n: return 0
return fact[n] * fact_inv[k] % MOD * fact_inv[n-k] % MOD
def cumprod(arr, MOD):
L = len(arr); Lsq = int(L**.5+1)
arr = np.resize(arr, Lsq**2).reshape(Lsq, Lsq)
for n in range(1, Lsq):
arr[:, n] *= arr[:, n-1]; arr[:, n] %= MOD
for n in range(1, Lsq):
arr[n] *= arr[n-1, -1]; arr[n] %= MOD
return arr.ravel()[:L]
def make_fact(U, MOD):
x = np.arange(U, dtype=np.int64); x[0] = 1
fact = cumprod(x, MOD)
x = np.arange(U, 0, -1, dtype=np.int64); x[0] = pow(int(fact[-1]), MOD-2, MOD)
fact_inv = cumprod(x, MOD)[::-1]
return fact, fact_inv
U = 2005 # 階乗テーブルの上限
fact, fact_inv = make_fact(U, MOD)
for i in range(1, K+1):
answer = cmb(N-K+1, i)
if K > i:
#１つずつ全てに配置すると残りはK-i個、壁はi-1個
answer *= cmb(K-i+i-1, K-i)
print((answer % MOD))
# 38
| 43 | 39 | 1,148 | 1,076 |
import sys
import numpy as np
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
def cmb(n, k):
if n < k:
return 0
return fact[n] * fact_inv[k] % MOD * fact_inv[n - k] % MOD
def cumprod(arr, MOD):
L = len(arr)
Lsq = int(L**0.5 + 1)
arr = np.resize(arr, Lsq**2).reshape(Lsq, Lsq)
for n in range(1, Lsq):
arr[:, n] *= arr[:, n - 1]
arr[:, n] %= MOD
for n in range(1, Lsq):
arr[n] *= arr[n - 1, -1]
arr[n] %= MOD
return arr.ravel()[:L]
def make_fact(U, MOD):
x = np.arange(U, dtype=np.int64)
x[0] = 1
fact = cumprod(x, MOD)
x = np.arange(U, 0, -1, dtype=np.int64)
x[0] = pow(int(fact[-1]), MOD - 2, MOD)
fact_inv = cumprod(x, MOD)[::-1]
return fact, fact_inv
N, K = lr()
MOD = 10**9 + 7
U = 2010 # 階乗テーブルの上限
fact, fact_inv = make_fact(U, MOD)
red = N - K
for i in range(1, K + 1):
# (red+1)Ci
answer = cmb(red + 1, i)
# print(answer)
remain = K - i
# remainをiの中に自由にいれる、i-1の壁を用意
# (remain+(i-1)) C remain
answer *= cmb(remain + i - 1, remain)
print((answer % MOD))
# 15
|
import sys
import numpy as np
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
MOD = 10**9 + 7
N, K = lr()
def cmb(n, k):
if k < 0 or k > n:
return 0
return fact[n] * fact_inv[k] % MOD * fact_inv[n - k] % MOD
def cumprod(arr, MOD):
L = len(arr)
Lsq = int(L**0.5 + 1)
arr = np.resize(arr, Lsq**2).reshape(Lsq, Lsq)
for n in range(1, Lsq):
arr[:, n] *= arr[:, n - 1]
arr[:, n] %= MOD
for n in range(1, Lsq):
arr[n] *= arr[n - 1, -1]
arr[n] %= MOD
return arr.ravel()[:L]
def make_fact(U, MOD):
x = np.arange(U, dtype=np.int64)
x[0] = 1
fact = cumprod(x, MOD)
x = np.arange(U, 0, -1, dtype=np.int64)
x[0] = pow(int(fact[-1]), MOD - 2, MOD)
fact_inv = cumprod(x, MOD)[::-1]
return fact, fact_inv
U = 2005 # 階乗テーブルの上限
fact, fact_inv = make_fact(U, MOD)
for i in range(1, K + 1):
answer = cmb(N - K + 1, i)
if K > i:
# １つずつ全てに配置すると残りはK-i個、壁はi-1個
answer *= cmb(K - i + i - 1, K - i)
print((answer % MOD))
# 38
| false | 9.302326 |
[
"+MOD = 10**9 + 7",
"+N, K = lr()",
"- if n < k:",
"+ if k < 0 or k > n:",
"-N, K = lr()",
"-MOD = 10**9 + 7",
"-U = 2010 # 階乗テーブルの上限",
"+U = 2005 # 階乗テーブルの上限",
"-red = N - K",
"- # (red+1)Ci",
"- answer = cmb(red + 1, i)",
"- # print(answer)",
"- remain = K - i",
"- # remainをiの中に自由にいれる、i-1の壁を用意",
"- # (remain+(i-1)) C remain",
"- answer *= cmb(remain + i - 1, remain)",
"+ answer = cmb(N - K + 1, i)",
"+ if K > i:",
"+ # １つずつ全てに配置すると残りはK-i個、壁はi-1個",
"+ answer *= cmb(K - i + i - 1, K - i)",
"-# 15",
"+# 38"
] | false | 0.456714 | 0.446219 | 1.023521 |
[
"s958355831",
"s579426240"
] |
u133936772
|
p03087
|
python
|
s261607670
|
s092485966
| 892 | 283 | 7,748 | 7,916 |
Accepted
|
Accepted
| 68.27 |
f = lambda : list(map(int,input().split()))
n, q = f()
s = eval(input())
ln = [0]*n
for i in range(1,n):
ln[i] = ln[i-1] + (s[i-1:i+1]=='AC')
for _ in range(q):
l, r = f()
print((ln[r-1]-ln[l-1]))
|
import sys
input = sys.stdin.readline
f = lambda : list(map(int,input().split()))
n, q = f()
s = eval(input())
ln = [0]*n
for i in range(1,n):
ln[i] = ln[i-1] + (s[i-1:i+1]=='AC')
for _ in range(q):
l, r = f()
print((ln[r-1] - ln[l-1]))
| 12 | 14 | 202 | 244 |
f = lambda: list(map(int, input().split()))
n, q = f()
s = eval(input())
ln = [0] * n
for i in range(1, n):
ln[i] = ln[i - 1] + (s[i - 1 : i + 1] == "AC")
for _ in range(q):
l, r = f()
print((ln[r - 1] - ln[l - 1]))
|
import sys
input = sys.stdin.readline
f = lambda: list(map(int, input().split()))
n, q = f()
s = eval(input())
ln = [0] * n
for i in range(1, n):
ln[i] = ln[i - 1] + (s[i - 1 : i + 1] == "AC")
for _ in range(q):
l, r = f()
print((ln[r - 1] - ln[l - 1]))
| false | 14.285714 |
[
"+import sys",
"+",
"+input = sys.stdin.readline"
] | false | 0.038151 | 0.045727 | 0.83432 |
[
"s261607670",
"s092485966"
] |
u644907318
|
p02879
|
python
|
s716437579
|
s888960860
| 165 | 64 | 38,384 | 61,816 |
Accepted
|
Accepted
| 61.21 |
A,B = list(map(int,input().split()))
if A<=9 and B<=9:
print((A*B))
else:
print((-1))
|
A,B = list(map(int,input().split()))
if 1<=A<=9 and 1<=B<=9:
print((A*B))
else:
print((-1))
| 5 | 5 | 87 | 93 |
A, B = list(map(int, input().split()))
if A <= 9 and B <= 9:
print((A * B))
else:
print((-1))
|
A, B = list(map(int, input().split()))
if 1 <= A <= 9 and 1 <= B <= 9:
print((A * B))
else:
print((-1))
| false | 0 |
[
"-if A <= 9 and B <= 9:",
"+if 1 <= A <= 9 and 1 <= B <= 9:"
] | false | 0.068483 | 0.037166 | 1.842641 |
[
"s716437579",
"s888960860"
] |
u054514819
|
p03633
|
python
|
s901848931
|
s833361007
| 99 | 63 | 62,268 | 62,108 |
Accepted
|
Accepted
| 36.36 |
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return list(map(int, input().split()))
sys.setrecursionlimit(10**9)
N = int(eval(input()))
from math import gcd
ans = 1
for i in range(N):
t = int(eval(input()))
g = gcd(ans, t)
ans = ans*t//g
print(ans)
|
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return list(map(int, input().split()))
sys.setrecursionlimit(10**9)
N = int(eval(input()))
from math import gcd
g = 0
ans = 1
for _ in range(N):
t = int(eval(input()))
g = gcd(t, ans)
ans = t*ans//g
print(ans)
| 15 | 14 | 288 | 291 |
import sys
def input():
return sys.stdin.readline().strip()
def mapint():
return list(map(int, input().split()))
sys.setrecursionlimit(10**9)
N = int(eval(input()))
from math import gcd
ans = 1
for i in range(N):
t = int(eval(input()))
g = gcd(ans, t)
ans = ans * t // g
print(ans)
|
import sys
def input():
return sys.stdin.readline().strip()
def mapint():
return list(map(int, input().split()))
sys.setrecursionlimit(10**9)
N = int(eval(input()))
from math import gcd
g = 0
ans = 1
for _ in range(N):
t = int(eval(input()))
g = gcd(t, ans)
ans = t * ans // g
print(ans)
| false | 6.666667 |
[
"+g = 0",
"-for i in range(N):",
"+for _ in range(N):",
"- g = gcd(ans, t)",
"- ans = ans * t // g",
"+ g = gcd(t, ans)",
"+ ans = t * ans // g"
] | false | 0.047517 | 0.047661 | 0.996986 |
[
"s901848931",
"s833361007"
] |
u127499732
|
p03503
|
python
|
s545876987
|
s786414192
| 188 | 167 | 3,064 | 3,188 |
Accepted
|
Accepted
| 11.17 |
def main():
from itertools import product
n = int(eval(input()))
f = [list(map(int, input().split())) for _ in range(n)]
p = [list(map(int, input().split())) for _ in range(n)]
l = [[0, 0], [1, 0], [0, 1], [1, 1]]
r = list(range(4))
ans = - 10 ** 9
for c in product(r, r, r, r, r):
v = [l[i] for i in c]
s = sum(v, [])
if sum(s) == 0:
continue
t = 0
for x, y in zip(f, p):
m = sum([i * j for i, j in zip(s, x)])
t += y[m]
ans = max(ans, t)
print(ans)
if __name__ == '__main__':
main()
|
def main():
from itertools import product
import heapq
n = int(eval(input()))
f = [list(map(int, input().split())) for _ in range(n)]
p = [list(map(int, input().split())) for _ in range(n)]
l = [[0, 0], [1, 0], [0, 1], [1, 1]]
r = list(range(4))
ans = []
heapq.heapify(ans)
for c in product(r, r, r, r, r):
v = [l[i] for i in c]
s = sum(v, [])
if sum(s) == 0:
continue
t = sum(y[sum([i * j for i, j in zip(s, x)])] for x, y in zip(f, p))
heapq.heappush(ans, -t)
print((-1 * heapq.heappop(ans)))
if __name__ == '__main__':
main()
| 26 | 25 | 627 | 644 |
def main():
from itertools import product
n = int(eval(input()))
f = [list(map(int, input().split())) for _ in range(n)]
p = [list(map(int, input().split())) for _ in range(n)]
l = [[0, 0], [1, 0], [0, 1], [1, 1]]
r = list(range(4))
ans = -(10**9)
for c in product(r, r, r, r, r):
v = [l[i] for i in c]
s = sum(v, [])
if sum(s) == 0:
continue
t = 0
for x, y in zip(f, p):
m = sum([i * j for i, j in zip(s, x)])
t += y[m]
ans = max(ans, t)
print(ans)
if __name__ == "__main__":
main()
|
def main():
from itertools import product
import heapq
n = int(eval(input()))
f = [list(map(int, input().split())) for _ in range(n)]
p = [list(map(int, input().split())) for _ in range(n)]
l = [[0, 0], [1, 0], [0, 1], [1, 1]]
r = list(range(4))
ans = []
heapq.heapify(ans)
for c in product(r, r, r, r, r):
v = [l[i] for i in c]
s = sum(v, [])
if sum(s) == 0:
continue
t = sum(y[sum([i * j for i, j in zip(s, x)])] for x, y in zip(f, p))
heapq.heappush(ans, -t)
print((-1 * heapq.heappop(ans)))
if __name__ == "__main__":
main()
| false | 3.846154 |
[
"+ import heapq",
"- ans = -(10**9)",
"+ ans = []",
"+ heapq.heapify(ans)",
"- t = 0",
"- for x, y in zip(f, p):",
"- m = sum([i * j for i, j in zip(s, x)])",
"- t += y[m]",
"- ans = max(ans, t)",
"- print(ans)",
"+ t = sum(y[sum([i * j for i, j in zip(s, x)])] for x, y in zip(f, p))",
"+ heapq.heappush(ans, -t)",
"+ print((-1 * heapq.heappop(ans)))"
] | false | 0.078383 | 0.084872 | 0.923536 |
[
"s545876987",
"s786414192"
] |
u347640436
|
p03426
|
python
|
s201407944
|
s545003267
| 1,094 | 587 | 28,644 | 35,428 |
Accepted
|
Accepted
| 46.34 |
H, W, D = list(map(int, input().split()))
A = [list(map(int, input().split())) for _ in range(H)]
d = {}
for y in range(H):
for x in range(W):
d[A[y][x]] = (y, x)
t = [[0] * (H * W // D + 1) for _ in range(D)]
for i in range(D):
j = 0
if i == 0:
j = 1
while i + (j + 1) * D <= H * W:
y1, x1 = d[i + j * D]
y2, x2 = d[i + (j + 1) * D]
t[i][j + 1] = abs(y1 - y2) + abs(x1 - x2)
j += 1
for j in range(H * W // D):
t[i][j + 1] += t[i][j]
Q = int(eval(input()))
for _ in range(Q):
L, R = list(map(int, input().split()))
i = L % D
print((t[i][(R - i) // D] - t[i][(L - i) // D]))
|
H, W, D = list(map(int, input().split()))
A = [list(map(int, input().split())) for _ in range(H)]
d = {}
for y in range(H):
for x in range(W):
d[A[y][x]] = (y, x)
t = [[0] * (H * W // D + 1) for _ in range(D)]
for i in range(D):
j = 0
if i == 0:
j = 1
while i + (j + 1) * D <= H * W:
y1, x1 = d[i + j * D]
y2, x2 = d[i + (j + 1) * D]
t[i][j + 1] = abs(y1 - y2) + abs(x1 - x2)
j += 1
for j in range(H * W // D):
t[i][j + 1] += t[i][j]
Q = int(eval(input()))
result = []
for _ in range(Q):
L, R = list(map(int, input().split()))
i = L % D
result.append(t[i][(R - i) // D] - t[i][(L - i) // D])
print(('\n'.join(str(i) for i in result)))
| 26 | 28 | 670 | 733 |
H, W, D = list(map(int, input().split()))
A = [list(map(int, input().split())) for _ in range(H)]
d = {}
for y in range(H):
for x in range(W):
d[A[y][x]] = (y, x)
t = [[0] * (H * W // D + 1) for _ in range(D)]
for i in range(D):
j = 0
if i == 0:
j = 1
while i + (j + 1) * D <= H * W:
y1, x1 = d[i + j * D]
y2, x2 = d[i + (j + 1) * D]
t[i][j + 1] = abs(y1 - y2) + abs(x1 - x2)
j += 1
for j in range(H * W // D):
t[i][j + 1] += t[i][j]
Q = int(eval(input()))
for _ in range(Q):
L, R = list(map(int, input().split()))
i = L % D
print((t[i][(R - i) // D] - t[i][(L - i) // D]))
|
H, W, D = list(map(int, input().split()))
A = [list(map(int, input().split())) for _ in range(H)]
d = {}
for y in range(H):
for x in range(W):
d[A[y][x]] = (y, x)
t = [[0] * (H * W // D + 1) for _ in range(D)]
for i in range(D):
j = 0
if i == 0:
j = 1
while i + (j + 1) * D <= H * W:
y1, x1 = d[i + j * D]
y2, x2 = d[i + (j + 1) * D]
t[i][j + 1] = abs(y1 - y2) + abs(x1 - x2)
j += 1
for j in range(H * W // D):
t[i][j + 1] += t[i][j]
Q = int(eval(input()))
result = []
for _ in range(Q):
L, R = list(map(int, input().split()))
i = L % D
result.append(t[i][(R - i) // D] - t[i][(L - i) // D])
print(("\n".join(str(i) for i in result)))
| false | 7.142857 |
[
"+result = []",
"- print((t[i][(R - i) // D] - t[i][(L - i) // D]))",
"+ result.append(t[i][(R - i) // D] - t[i][(L - i) // D])",
"+print((\"\\n\".join(str(i) for i in result)))"
] | false | 0.036961 | 0.036671 | 1.00792 |
[
"s201407944",
"s545003267"
] |
u968166680
|
p02839
|
python
|
s233860603
|
s908023337
| 1,536 | 1,342 | 546,248 | 227,308 |
Accepted
|
Accepted
| 12.63 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
H, W = list(map(int, readline().split()))
A = [list(map(int, readline().split())) for _ in range(H)]
B = [list(map(int, readline().split())) for _ in range(H)]
G = [[0] * W for _ in range(H)]
for i in range(H):
for j in range(W):
G[i][j] = abs(A[i][j] - B[i][j])
dp = [[set() for j in range(W)] for i in range(H)]
dp[0][0].add(G[0][0])
for i in range(H):
for j in range(W):
if i == 0 and j == 0:
continue
s = dp[i][j]
b = G[i][j]
if i > 0:
for k in dp[i - 1][j]:
s.add(k + b)
s.add(abs(k - b))
if j > 0:
for k in dp[i][j - 1]:
s.add(k + b)
s.add(abs(k - b))
print((min(dp[H - 1][W - 1])))
return
if __name__ == '__main__':
main()
|
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
H, W = list(map(int, readline().split()))
A = [list(map(int, readline().split())) for _ in range(H)]
B = [list(map(int, readline().split())) for _ in range(H)]
G = [[0] * W for _ in range(H)]
for i in range(H):
for j in range(W):
G[i][j] = abs(A[i][j] - B[i][j])
dp = [set() for j in range(W)]
dp[0].add(G[0][0])
for i in range(H):
for j in range(W):
if i == 0 and j == 0:
continue
s = set()
b = G[i][j]
if i > 0:
for k in dp[j]:
s.add(k + b)
s.add(abs(k - b))
if j > 0:
for k in dp[j - 1]:
s.add(k + b)
s.add(abs(k - b))
dp[j] = s
print((min(dp[W - 1])))
return
if __name__ == '__main__':
main()
| 44 | 45 | 1,103 | 1,083 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10**9)
INF = 1 << 60
MOD = 1000000007
def main():
H, W = list(map(int, readline().split()))
A = [list(map(int, readline().split())) for _ in range(H)]
B = [list(map(int, readline().split())) for _ in range(H)]
G = [[0] * W for _ in range(H)]
for i in range(H):
for j in range(W):
G[i][j] = abs(A[i][j] - B[i][j])
dp = [[set() for j in range(W)] for i in range(H)]
dp[0][0].add(G[0][0])
for i in range(H):
for j in range(W):
if i == 0 and j == 0:
continue
s = dp[i][j]
b = G[i][j]
if i > 0:
for k in dp[i - 1][j]:
s.add(k + b)
s.add(abs(k - b))
if j > 0:
for k in dp[i][j - 1]:
s.add(k + b)
s.add(abs(k - b))
print((min(dp[H - 1][W - 1])))
return
if __name__ == "__main__":
main()
|
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10**9)
INF = 1 << 60
MOD = 1000000007
def main():
H, W = list(map(int, readline().split()))
A = [list(map(int, readline().split())) for _ in range(H)]
B = [list(map(int, readline().split())) for _ in range(H)]
G = [[0] * W for _ in range(H)]
for i in range(H):
for j in range(W):
G[i][j] = abs(A[i][j] - B[i][j])
dp = [set() for j in range(W)]
dp[0].add(G[0][0])
for i in range(H):
for j in range(W):
if i == 0 and j == 0:
continue
s = set()
b = G[i][j]
if i > 0:
for k in dp[j]:
s.add(k + b)
s.add(abs(k - b))
if j > 0:
for k in dp[j - 1]:
s.add(k + b)
s.add(abs(k - b))
dp[j] = s
print((min(dp[W - 1])))
return
if __name__ == "__main__":
main()
| false | 2.222222 |
[
"- dp = [[set() for j in range(W)] for i in range(H)]",
"- dp[0][0].add(G[0][0])",
"+ dp = [set() for j in range(W)]",
"+ dp[0].add(G[0][0])",
"- s = dp[i][j]",
"+ s = set()",
"- for k in dp[i - 1][j]:",
"+ for k in dp[j]:",
"- for k in dp[i][j - 1]:",
"+ for k in dp[j - 1]:",
"- print((min(dp[H - 1][W - 1])))",
"+ dp[j] = s",
"+ print((min(dp[W - 1])))"
] | false | 0.078122 | 0.036759 | 2.125274 |
[
"s233860603",
"s908023337"
] |
u755215227
|
p03163
|
python
|
s575737227
|
s204676755
| 468 | 295 | 119,660 | 45,424 |
Accepted
|
Accepted
| 36.97 |
N,W = [int(i) for i in input().split()]
w = [] # limit weight to knapsack capacity
v = [] # maximize value
for i in range(N):
line = input().split()
w.append(int(line[0]))
v.append(int(line[1]))
mem = [[0]*(W+1) for i in range(N)]
for i in range(w[0], W+1):
mem[0][i] = v[0]
for i in range(1, N):
for j in range(1, W+1):
if w[i] > j:
mem[i][j] = mem[i-1][j]
else:
mem[i][j] = max(mem[i-1][j], v[i] + mem[i-1][j - w[i]])
#print(mem)
print(("%s" % mem[N-1][W]))
|
N,W = [int(i) for i in input().split()]
dp = [0 for i in range(W+1)] # dp[i] is the the max value you have achieve with weight i
for i in range(N):
w,value = [int(i) for i in input().split()]
for weight in range(W-w, -1, -1): # range of kanpsack weight in which i can push the current item
dp[weight + w] = max(dp[weight + w], dp[weight] + value)
print(("%s" % dp[W]))
| 18 | 7 | 504 | 380 |
N, W = [int(i) for i in input().split()]
w = [] # limit weight to knapsack capacity
v = [] # maximize value
for i in range(N):
line = input().split()
w.append(int(line[0]))
v.append(int(line[1]))
mem = [[0] * (W + 1) for i in range(N)]
for i in range(w[0], W + 1):
mem[0][i] = v[0]
for i in range(1, N):
for j in range(1, W + 1):
if w[i] > j:
mem[i][j] = mem[i - 1][j]
else:
mem[i][j] = max(mem[i - 1][j], v[i] + mem[i - 1][j - w[i]])
# print(mem)
print(("%s" % mem[N - 1][W]))
|
N, W = [int(i) for i in input().split()]
dp = [
0 for i in range(W + 1)
] # dp[i] is the the max value you have achieve with weight i
for i in range(N):
w, value = [int(i) for i in input().split()]
for weight in range(
W - w, -1, -1
): # range of kanpsack weight in which i can push the current item
dp[weight + w] = max(dp[weight + w], dp[weight] + value)
print(("%s" % dp[W]))
| false | 61.111111 |
[
"-w = [] # limit weight to knapsack capacity",
"-v = [] # maximize value",
"+dp = [",
"+ 0 for i in range(W + 1)",
"+] # dp[i] is the the max value you have achieve with weight i",
"- line = input().split()",
"- w.append(int(line[0]))",
"- v.append(int(line[1]))",
"-mem = [[0] * (W + 1) for i in range(N)]",
"-for i in range(w[0], W + 1):",
"- mem[0][i] = v[0]",
"-for i in range(1, N):",
"- for j in range(1, W + 1):",
"- if w[i] > j:",
"- mem[i][j] = mem[i - 1][j]",
"- else:",
"- mem[i][j] = max(mem[i - 1][j], v[i] + mem[i - 1][j - w[i]])",
"-# print(mem)",
"-print((\"%s\" % mem[N - 1][W]))",
"+ w, value = [int(i) for i in input().split()]",
"+ for weight in range(",
"+ W - w, -1, -1",
"+ ): # range of kanpsack weight in which i can push the current item",
"+ dp[weight + w] = max(dp[weight + w], dp[weight] + value)",
"+print((\"%s\" % dp[W]))"
] | false | 0.048316 | 0.047451 | 1.018225 |
[
"s575737227",
"s204676755"
] |
u764393353
|
p02658
|
python
|
s556419893
|
s200142731
| 157 | 93 | 91,276 | 87,848 |
Accepted
|
Accepted
| 40.76 |
from functools import reduce
from operator import mul
import math
def main():
n = int(eval(input()))
l = list(map(int, input().split()))
if 0 in l:
print((0))
return
l_sorted = sorted(l, reverse=True)
log = 0
seki = 1
for i in l_sorted:
log += math.log10(i)
if log > 18:
print((-1))
return
elif log == 18:
seki *= i
if seki != 10 ** 18:
print((-1))
return
else:
seki *= i
print(seki)
return
if __name__ == '__main__':
main()
|
def main():
n = int(eval(input()))
l = list(map(int, input().split()))
if 0 in l:
print((0))
return
prod = 1
for i in l:
prod *= i
if prod > 1000000000000000000:
print((-1))
return
print(prod)
if __name__ == '__main__':
main()
| 32 | 19 | 627 | 322 |
from functools import reduce
from operator import mul
import math
def main():
n = int(eval(input()))
l = list(map(int, input().split()))
if 0 in l:
print((0))
return
l_sorted = sorted(l, reverse=True)
log = 0
seki = 1
for i in l_sorted:
log += math.log10(i)
if log > 18:
print((-1))
return
elif log == 18:
seki *= i
if seki != 10**18:
print((-1))
return
else:
seki *= i
print(seki)
return
if __name__ == "__main__":
main()
|
def main():
n = int(eval(input()))
l = list(map(int, input().split()))
if 0 in l:
print((0))
return
prod = 1
for i in l:
prod *= i
if prod > 1000000000000000000:
print((-1))
return
print(prod)
if __name__ == "__main__":
main()
| false | 40.625 |
[
"-from functools import reduce",
"-from operator import mul",
"-import math",
"-",
"-",
"- l_sorted = sorted(l, reverse=True)",
"- log = 0",
"- seki = 1",
"- for i in l_sorted:",
"- log += math.log10(i)",
"- if log > 18:",
"+ prod = 1",
"+ for i in l:",
"+ prod *= i",
"+ if prod > 1000000000000000000:",
"- elif log == 18:",
"- seki *= i",
"- if seki != 10**18:",
"- print((-1))",
"- return",
"- else:",
"- seki *= i",
"- print(seki)",
"- return",
"+ print(prod)"
] | false | 0.035576 | 0.055748 | 0.638164 |
[
"s556419893",
"s200142731"
] |
u186838327
|
p03659
|
python
|
s289990496
|
s076496208
| 142 | 116 | 24,832 | 103,272 |
Accepted
|
Accepted
| 18.31 |
n = int(eval(input()))
l = list(map(int, input().split()))
a = sum(l)
min_s = float('inf')
x = 0
for i in range(n-1):
x += l[i]
s = abs(a-2*x)
if s <= min_s:
min_s = s
print(min_s)
|
n = int(eval(input()))
A = list(map(int, input().split()))
S = sum(A)
from itertools import accumulate
C = [0]+A
C = list(accumulate(C))
ans = 10**18
for i in range(1, n):
s = C[i]
a = S-s
ans = min(ans, abs(s-a))
print(ans)
| 12 | 14 | 196 | 246 |
n = int(eval(input()))
l = list(map(int, input().split()))
a = sum(l)
min_s = float("inf")
x = 0
for i in range(n - 1):
x += l[i]
s = abs(a - 2 * x)
if s <= min_s:
min_s = s
print(min_s)
|
n = int(eval(input()))
A = list(map(int, input().split()))
S = sum(A)
from itertools import accumulate
C = [0] + A
C = list(accumulate(C))
ans = 10**18
for i in range(1, n):
s = C[i]
a = S - s
ans = min(ans, abs(s - a))
print(ans)
| false | 14.285714 |
[
"-l = list(map(int, input().split()))",
"-a = sum(l)",
"-min_s = float(\"inf\")",
"-x = 0",
"-for i in range(n - 1):",
"- x += l[i]",
"- s = abs(a - 2 * x)",
"- if s <= min_s:",
"- min_s = s",
"-print(min_s)",
"+A = list(map(int, input().split()))",
"+S = sum(A)",
"+from itertools import accumulate",
"+",
"+C = [0] + A",
"+C = list(accumulate(C))",
"+ans = 10**18",
"+for i in range(1, n):",
"+ s = C[i]",
"+ a = S - s",
"+ ans = min(ans, abs(s - a))",
"+print(ans)"
] | false | 0.041542 | 0.036452 | 1.139638 |
[
"s289990496",
"s076496208"
] |
u321605735
|
p02676
|
python
|
s163942263
|
s833173198
| 31 | 25 | 9,080 | 9,156 |
Accepted
|
Accepted
| 19.35 |
K=int(eval(input()))
S=eval(input())
if len(S)<=K:
print(S)
else:
print((S[0:K]+"..."))
|
K=int(eval(input()))
S=eval(input())
if len(S)<=K:
print(S)
else:
print((S[:K]+"..."))
| 6 | 6 | 86 | 85 |
K = int(eval(input()))
S = eval(input())
if len(S) <= K:
print(S)
else:
print((S[0:K] + "..."))
|
K = int(eval(input()))
S = eval(input())
if len(S) <= K:
print(S)
else:
print((S[:K] + "..."))
| false | 0 |
[
"- print((S[0:K] + \"...\"))",
"+ print((S[:K] + \"...\"))"
] | false | 0.044087 | 0.038271 | 1.151991 |
[
"s163942263",
"s833173198"
] |
u297574184
|
p02785
|
python
|
s805662850
|
s341348166
| 162 | 107 | 26,360 | 31,568 |
Accepted
|
Accepted
| 33.95 |
N, K = list(map(int, input().split()))
Hs = list(map(int, input().split()))
Hs.sort(reverse=True)
ans = sum(Hs) - sum(Hs[:K])
print(ans)
|
N, K = list(map(int, input().split()))
Hs = list(map(int, input().split()))
Hs.sort(reverse=True)
ans = sum(Hs[K:])
print(ans)
| 8 | 7 | 141 | 129 |
N, K = list(map(int, input().split()))
Hs = list(map(int, input().split()))
Hs.sort(reverse=True)
ans = sum(Hs) - sum(Hs[:K])
print(ans)
|
N, K = list(map(int, input().split()))
Hs = list(map(int, input().split()))
Hs.sort(reverse=True)
ans = sum(Hs[K:])
print(ans)
| false | 12.5 |
[
"-ans = sum(Hs) - sum(Hs[:K])",
"+ans = sum(Hs[K:])"
] | false | 0.04691 | 0.03843 | 1.220661 |
[
"s805662850",
"s341348166"
] |
u729939940
|
p02779
|
python
|
s226142024
|
s626905934
| 142 | 61 | 44,340 | 31,156 |
Accepted
|
Accepted
| 57.04 |
N = int(eval(input()))
A = list(map(int, input().split()))
cnt = {}
for a in A:
if cnt.get(a):
cnt[a] = cnt[a] + 1
else:
cnt[a] = 1
for v in list(cnt.values()):
if v != 1:
print('NO')
exit()
print('YES')
|
N = int(eval(input()))
A = input().split()
if len(A) == len(set(A)):
print('YES')
else:
print('NO')
| 13 | 6 | 219 | 102 |
N = int(eval(input()))
A = list(map(int, input().split()))
cnt = {}
for a in A:
if cnt.get(a):
cnt[a] = cnt[a] + 1
else:
cnt[a] = 1
for v in list(cnt.values()):
if v != 1:
print("NO")
exit()
print("YES")
|
N = int(eval(input()))
A = input().split()
if len(A) == len(set(A)):
print("YES")
else:
print("NO")
| false | 53.846154 |
[
"-A = list(map(int, input().split()))",
"-cnt = {}",
"-for a in A:",
"- if cnt.get(a):",
"- cnt[a] = cnt[a] + 1",
"- else:",
"- cnt[a] = 1",
"-for v in list(cnt.values()):",
"- if v != 1:",
"- print(\"NO\")",
"- exit()",
"-print(\"YES\")",
"+A = input().split()",
"+if len(A) == len(set(A)):",
"+ print(\"YES\")",
"+else:",
"+ print(\"NO\")"
] | false | 0.036136 | 0.039905 | 0.905551 |
[
"s226142024",
"s626905934"
] |
u474983612
|
p01712
|
python
|
s904121624
|
s680116433
| 710 | 620 | 11,476 | 11,512 |
Accepted
|
Accepted
| 12.68 |
N, W, H = [int(x) for x in input().split()]
map_x = [0] * W
map_y = [0] * H
for _ in range(N):
x, y, w = [int(x) for x in input().split()]
map_x[max(0, x - w)] = max(map_x[max(0, x - w)], x + w - max(0, x - w))
map_y[max(0, y - w)] = max(map_y[max(0, y - w)], y + w - max(0, y - w))
def check_wifi(wifi):
m = 0
end = len(wifi)
for i, x in enumerate(wifi):
if x and i + x > m:
m = i + x
if m >= end:
return True
if i < m:
continue
return False
return False
print(('Yes' if check_wifi(map_x) or check_wifi(map_y) else 'No'))
|
N, W, H = [int(x) for x in input().split()]
map_x = [0] * W
map_y = [0] * H
for _ in range(N):
x, y, w = [int(x) for x in input().split()]
mx = max(0, x - w)
map_x[mx] = max(map_x[mx], x + w - mx)
my = max(0, y - w)
map_y[my] = max(map_y[my], y + w - my)
def check_wifi(wifi):
m = 0
end = len(wifi)
for i, x in enumerate(wifi):
if x and i + x > m:
m = i + x
if m >= end:
return True
if i < m:
continue
return False
return False
print(('Yes' if check_wifi(map_x) or check_wifi(map_y) else 'No'))
| 31 | 33 | 657 | 639 |
N, W, H = [int(x) for x in input().split()]
map_x = [0] * W
map_y = [0] * H
for _ in range(N):
x, y, w = [int(x) for x in input().split()]
map_x[max(0, x - w)] = max(map_x[max(0, x - w)], x + w - max(0, x - w))
map_y[max(0, y - w)] = max(map_y[max(0, y - w)], y + w - max(0, y - w))
def check_wifi(wifi):
m = 0
end = len(wifi)
for i, x in enumerate(wifi):
if x and i + x > m:
m = i + x
if m >= end:
return True
if i < m:
continue
return False
return False
print(("Yes" if check_wifi(map_x) or check_wifi(map_y) else "No"))
|
N, W, H = [int(x) for x in input().split()]
map_x = [0] * W
map_y = [0] * H
for _ in range(N):
x, y, w = [int(x) for x in input().split()]
mx = max(0, x - w)
map_x[mx] = max(map_x[mx], x + w - mx)
my = max(0, y - w)
map_y[my] = max(map_y[my], y + w - my)
def check_wifi(wifi):
m = 0
end = len(wifi)
for i, x in enumerate(wifi):
if x and i + x > m:
m = i + x
if m >= end:
return True
if i < m:
continue
return False
return False
print(("Yes" if check_wifi(map_x) or check_wifi(map_y) else "No"))
| false | 6.060606 |
[
"- map_x[max(0, x - w)] = max(map_x[max(0, x - w)], x + w - max(0, x - w))",
"- map_y[max(0, y - w)] = max(map_y[max(0, y - w)], y + w - max(0, y - w))",
"+ mx = max(0, x - w)",
"+ map_x[mx] = max(map_x[mx], x + w - mx)",
"+ my = max(0, y - w)",
"+ map_y[my] = max(map_y[my], y + w - my)"
] | false | 0.049144 | 0.11598 | 0.42373 |
[
"s904121624",
"s680116433"
] |
u227438830
|
p02398
|
python
|
s225596662
|
s647303062
| 30 | 20 | 7,640 | 5,596 |
Accepted
|
Accepted
| 33.33 |
a, b, c = list(map(int, input().split()))
l = [n for n in range (a,b+1) if c % n == 0]
print((len(l)))
|
cnt = 0
a, b, c = list(map(int,input().split()))
for i in range(a,b+1):
if c % i == 0:
cnt += 1
print(cnt)
| 3 | 6 | 96 | 118 |
a, b, c = list(map(int, input().split()))
l = [n for n in range(a, b + 1) if c % n == 0]
print((len(l)))
|
cnt = 0
a, b, c = list(map(int, input().split()))
for i in range(a, b + 1):
if c % i == 0:
cnt += 1
print(cnt)
| false | 50 |
[
"+cnt = 0",
"-l = [n for n in range(a, b + 1) if c % n == 0]",
"-print((len(l)))",
"+for i in range(a, b + 1):",
"+ if c % i == 0:",
"+ cnt += 1",
"+print(cnt)"
] | false | 0.039682 | 0.039859 | 0.995573 |
[
"s225596662",
"s647303062"
] |
u921168761
|
p03325
|
python
|
s162222692
|
s219394674
| 132 | 98 | 4,148 | 4,268 |
Accepted
|
Accepted
| 25.76 |
N = int(eval(input()))
a = list(map(int, input().split()))
ans = 0
for i in range(N):
while a[i] % 2 == 0:
a[i] /= 2
ans += 1
print(ans)
|
N = int(eval(input()))
a = list(map(int, input().split()))
ans = 0
for i in range(N):
while a[i] % 2 == 0:
a[i] //= 2
ans += 1
print(ans)
| 8 | 8 | 157 | 158 |
N = int(eval(input()))
a = list(map(int, input().split()))
ans = 0
for i in range(N):
while a[i] % 2 == 0:
a[i] /= 2
ans += 1
print(ans)
|
N = int(eval(input()))
a = list(map(int, input().split()))
ans = 0
for i in range(N):
while a[i] % 2 == 0:
a[i] //= 2
ans += 1
print(ans)
| false | 0 |
[
"- a[i] /= 2",
"+ a[i] //= 2"
] | false | 0.072384 | 0.11121 | 0.650874 |
[
"s162222692",
"s219394674"
] |
u768559443
|
p03071
|
python
|
s665072172
|
s424571752
| 178 | 17 | 38,472 | 2,940 |
Accepted
|
Accepted
| 90.45 |
a,b=list(map(int,input().split()))
print((max(a,b)*2-1+int(a==b)))
|
a,b=list(map(int,input().split()))
print((max(2*a-1,2*b-1,a+b)))
| 2 | 2 | 59 | 57 |
a, b = list(map(int, input().split()))
print((max(a, b) * 2 - 1 + int(a == b)))
|
a, b = list(map(int, input().split()))
print((max(2 * a - 1, 2 * b - 1, a + b)))
| false | 0 |
[
"-print((max(a, b) * 2 - 1 + int(a == b)))",
"+print((max(2 * a - 1, 2 * b - 1, a + b)))"
] | false | 0.041519 | 0.040047 | 1.036739 |
[
"s665072172",
"s424571752"
] |
u840958781
|
p02731
|
python
|
s169560937
|
s998565021
| 36 | 17 | 5,332 | 2,940 |
Accepted
|
Accepted
| 52.78 |
import decimal
l=eval(input())
l=decimal.Decimal(l)
m=decimal.Decimal(3)
print(((l/m)**3))
|
l=int(eval(input()))
print(((l/3)**3))
| 5 | 2 | 86 | 31 |
import decimal
l = eval(input())
l = decimal.Decimal(l)
m = decimal.Decimal(3)
print(((l / m) ** 3))
|
l = int(eval(input()))
print(((l / 3) ** 3))
| false | 60 |
[
"-import decimal",
"-",
"-l = eval(input())",
"-l = decimal.Decimal(l)",
"-m = decimal.Decimal(3)",
"-print(((l / m) ** 3))",
"+l = int(eval(input()))",
"+print(((l / 3) ** 3))"
] | false | 0.036 | 0.036709 | 0.980684 |
[
"s169560937",
"s998565021"
] |
u238786149
|
p02573
|
python
|
s745053135
|
s330090347
| 1,967 | 1,651 | 263,408 | 255,092 |
Accepted
|
Accepted
| 16.07 |
import networkx as nx
import sys
G = nx.Graph()
n, m = list(map(int, input().split()))
if m == 0:
print((1))
sys.exit()
for i in range(m):
a, b = list(map(int, input().split()))
G.add_edge(a, b)
largest_cc = max(nx.connected_components(G), key=len)
print((len(largest_cc)))
|
import networkx as nx
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
G = nx.Graph()
n, m = list(map(int, readline().split()))
if m == 0:
print((1))
sys.exit()
for i in range(m):
a, b = list(map(int, readline().split()))
G.add_edge(a, b)
largest_cc = max(nx.connected_components(G), key=len)
print((len(largest_cc)))
| 15 | 20 | 291 | 409 |
import networkx as nx
import sys
G = nx.Graph()
n, m = list(map(int, input().split()))
if m == 0:
print((1))
sys.exit()
for i in range(m):
a, b = list(map(int, input().split()))
G.add_edge(a, b)
largest_cc = max(nx.connected_components(G), key=len)
print((len(largest_cc)))
|
import networkx as nx
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
G = nx.Graph()
n, m = list(map(int, readline().split()))
if m == 0:
print((1))
sys.exit()
for i in range(m):
a, b = list(map(int, readline().split()))
G.add_edge(a, b)
largest_cc = max(nx.connected_components(G), key=len)
print((len(largest_cc)))
| false | 25 |
[
"+read = sys.stdin.buffer.read",
"+readline = sys.stdin.buffer.readline",
"+readlines = sys.stdin.buffer.readlines",
"-n, m = list(map(int, input().split()))",
"+n, m = list(map(int, readline().split()))",
"- a, b = list(map(int, input().split()))",
"+ a, b = list(map(int, readline().split()))"
] | false | 0.045333 | 0.043093 | 1.051998 |
[
"s745053135",
"s330090347"
] |
u597374218
|
p02681
|
python
|
s576713373
|
s684001590
| 24 | 20 | 8,968 | 9,036 |
Accepted
|
Accepted
| 16.67 |
S = eval(input())
T = eval(input())
print(("Yes" if S == T[:len(T)-1] else "No"))
|
S=eval(input())
T=eval(input())
print(("Yes" if S==T[:-1] else "No"))
| 3 | 3 | 69 | 57 |
S = eval(input())
T = eval(input())
print(("Yes" if S == T[: len(T) - 1] else "No"))
|
S = eval(input())
T = eval(input())
print(("Yes" if S == T[:-1] else "No"))
| false | 0 |
[
"-print((\"Yes\" if S == T[: len(T) - 1] else \"No\"))",
"+print((\"Yes\" if S == T[:-1] else \"No\"))"
] | false | 0.039698 | 0.074979 | 0.529459 |
[
"s576713373",
"s684001590"
] |
u562935282
|
p02757
|
python
|
s445249500
|
s681168789
| 458 | 130 | 5,096 | 5,096 |
Accepted
|
Accepted
| 71.62 |
def main():
N, P = list(map(int, input().split()))
S = [int(c) for c in eval(input())]
ret = 0
if P in {2, 5}:
for i, x in enumerate(S, 1):
if x % P == 0:
ret += i
print(ret)
return
else:
curr_num = 0
counter = [0] * P
counter[0] = 1
for i, x in enumerate(reversed(S)):
curr_num = (curr_num + x * pow(10, i, P)) % P
ret += counter[curr_num]
counter[curr_num] += 1
print(ret)
return
if __name__ == '__main__':
main()
|
def main():
N, P = list(map(int, input().split()))
S = [int(c) for c in eval(input())]
ret = 0
if P in {2, 5}:
for i, x in enumerate(S, 1):
if x % P == 0:
ret += i
print(ret)
return
else:
curr_num = 0
counter = [0] * P
counter[0] = 1
mul = 1
for i, x in enumerate(reversed(S)):
curr_num = (curr_num + x * mul) % P
ret += counter[curr_num]
counter[curr_num] += 1
mul = (mul * 10) % P
print(ret)
return
if __name__ == '__main__':
main()
| 26 | 28 | 593 | 634 |
def main():
N, P = list(map(int, input().split()))
S = [int(c) for c in eval(input())]
ret = 0
if P in {2, 5}:
for i, x in enumerate(S, 1):
if x % P == 0:
ret += i
print(ret)
return
else:
curr_num = 0
counter = [0] * P
counter[0] = 1
for i, x in enumerate(reversed(S)):
curr_num = (curr_num + x * pow(10, i, P)) % P
ret += counter[curr_num]
counter[curr_num] += 1
print(ret)
return
if __name__ == "__main__":
main()
|
def main():
N, P = list(map(int, input().split()))
S = [int(c) for c in eval(input())]
ret = 0
if P in {2, 5}:
for i, x in enumerate(S, 1):
if x % P == 0:
ret += i
print(ret)
return
else:
curr_num = 0
counter = [0] * P
counter[0] = 1
mul = 1
for i, x in enumerate(reversed(S)):
curr_num = (curr_num + x * mul) % P
ret += counter[curr_num]
counter[curr_num] += 1
mul = (mul * 10) % P
print(ret)
return
if __name__ == "__main__":
main()
| false | 7.142857 |
[
"+ mul = 1",
"- curr_num = (curr_num + x * pow(10, i, P)) % P",
"+ curr_num = (curr_num + x * mul) % P",
"+ mul = (mul * 10) % P"
] | false | 0.055695 | 0.054883 | 1.01479 |
[
"s445249500",
"s681168789"
] |
u077291787
|
p03673
|
python
|
s710075747
|
s742039415
| 200 | 169 | 25,948 | 25,180 |
Accepted
|
Accepted
| 15.5 |
# ABC066C - pushpush (ARC077)
from collections import deque
def main():
N, *A = list(map(int, open(0).read().split()))
B, x = deque(), int(N) & 1
for i, a in enumerate(A, start=x):
if i & 1:
B.appendleft(a)
else:
B.append(a)
print((*B))
if __name__ == "__main__":
main()
|
# ABC066C - pushpush (ARC077)
def main():
N, *A = list(map(int, open(0).read().split()))
if int(N) & 1:
B = A[::2][::-1] + A[1::2]
else:
B = A[1::2][::-1] + A[::2]
print((*B))
if __name__ == "__main__":
main()
| 17 | 12 | 342 | 250 |
# ABC066C - pushpush (ARC077)
from collections import deque
def main():
N, *A = list(map(int, open(0).read().split()))
B, x = deque(), int(N) & 1
for i, a in enumerate(A, start=x):
if i & 1:
B.appendleft(a)
else:
B.append(a)
print((*B))
if __name__ == "__main__":
main()
|
# ABC066C - pushpush (ARC077)
def main():
N, *A = list(map(int, open(0).read().split()))
if int(N) & 1:
B = A[::2][::-1] + A[1::2]
else:
B = A[1::2][::-1] + A[::2]
print((*B))
if __name__ == "__main__":
main()
| false | 29.411765 |
[
"-from collections import deque",
"-",
"-",
"- B, x = deque(), int(N) & 1",
"- for i, a in enumerate(A, start=x):",
"- if i & 1:",
"- B.appendleft(a)",
"- else:",
"- B.append(a)",
"+ if int(N) & 1:",
"+ B = A[::2][::-1] + A[1::2]",
"+ else:",
"+ B = A[1::2][::-1] + A[::2]"
] | false | 0.042505 | 0.04859 | 0.874759 |
[
"s710075747",
"s742039415"
] |
u134019875
|
p03137
|
python
|
s639209852
|
s523692298
| 125 | 106 | 13,968 | 13,968 |
Accepted
|
Accepted
| 15.2 |
n, m = list(map(int, input().split()))
L = sorted(map(int, input().split()))
d = [0] * (m - 1)
for i in range(1, m):
d[i - 1] = abs(L[i] - L[i - 1])
d = sorted(d, reverse=True)[(n - 1):]
print((sum(d)))
|
n, m = list(map(int, input().split()))
L = sorted(map(int, input().split()))
d = [L[i + 1] - L[i] for i in range(m - 1)]
d.sort(reverse=True)
print((sum(d[(n - 1):])))
| 7 | 5 | 205 | 164 |
n, m = list(map(int, input().split()))
L = sorted(map(int, input().split()))
d = [0] * (m - 1)
for i in range(1, m):
d[i - 1] = abs(L[i] - L[i - 1])
d = sorted(d, reverse=True)[(n - 1) :]
print((sum(d)))
|
n, m = list(map(int, input().split()))
L = sorted(map(int, input().split()))
d = [L[i + 1] - L[i] for i in range(m - 1)]
d.sort(reverse=True)
print((sum(d[(n - 1) :])))
| false | 28.571429 |
[
"-d = [0] * (m - 1)",
"-for i in range(1, m):",
"- d[i - 1] = abs(L[i] - L[i - 1])",
"-d = sorted(d, reverse=True)[(n - 1) :]",
"-print((sum(d)))",
"+d = [L[i + 1] - L[i] for i in range(m - 1)]",
"+d.sort(reverse=True)",
"+print((sum(d[(n - 1) :])))"
] | false | 0.041965 | 0.045233 | 0.92775 |
[
"s639209852",
"s523692298"
] |
u916323984
|
p02679
|
python
|
s304522526
|
s581799157
| 1,016 | 939 | 68,092 | 68,192 |
Accepted
|
Accepted
| 7.58 |
from collections import defaultdict
import math
def main():
n = int(eval(input()))
mod = 1000000007
zeroes = 0
counter1 = defaultdict(int)
counter2 = defaultdict(int)
for _ in range(n):
x, y = [int(x) for x in input().split()]
if x == y == 0:
zeroes += 1
continue
denominator = math.gcd(x, y)
x, y = x // denominator, y // denominator
if y < 0:
# quadrant III, IV -> I, II
x, y = -x, -y
if x <= 0:
# round 90° from quadrant II to I
x, y = y, -x
counter2[(x, y)] += 1
counter1[(x, y)] += 0
else:
counter1[(x, y)] += 1
counter2[(x, y)] += 0
ans = 1
for k, v in list(counter1.items()):
now = 1
now += pow(2, v, mod) - 1
now += pow(2, counter2[k], mod) - 1
ans = ans * now % mod
ans += zeroes
ans -= 1 # choose no fish
return ans % mod
if __name__ == '__main__':
print((main()))
|
from collections import defaultdict
import math
def main():
n = int(eval(input()))
mod = 1000000007
zeroes = 0
quadrant1 = defaultdict(int)
quadrant2 = defaultdict(int)
for _ in range(n):
a, b = list(map(int, input().split()))
if a == b == 0:
zeroes += 1
continue
g = math.gcd(a, b)
a, b = a//g, b//g
if b < 0:
a, b = -a, -b
if a <= 0:
a, b = b, -a
quadrant1[(a, b)] += 0
quadrant2[(a, b)] += 1
else:
quadrant1[(a, b)] += 1
quadrant2[(a, b)] += 0
ans = 1
for key, value in list(quadrant1.items()):
now = 1
now += pow(2, value, mod) - 1
now += pow(2, quadrant2[key], mod) - 1
ans = (ans * now) % mod
ans += (zeroes - 1)
return ans % mod
if __name__ == '__main__':
print((main()))
| 46 | 42 | 1,072 | 961 |
from collections import defaultdict
import math
def main():
n = int(eval(input()))
mod = 1000000007
zeroes = 0
counter1 = defaultdict(int)
counter2 = defaultdict(int)
for _ in range(n):
x, y = [int(x) for x in input().split()]
if x == y == 0:
zeroes += 1
continue
denominator = math.gcd(x, y)
x, y = x // denominator, y // denominator
if y < 0:
# quadrant III, IV -> I, II
x, y = -x, -y
if x <= 0:
# round 90° from quadrant II to I
x, y = y, -x
counter2[(x, y)] += 1
counter1[(x, y)] += 0
else:
counter1[(x, y)] += 1
counter2[(x, y)] += 0
ans = 1
for k, v in list(counter1.items()):
now = 1
now += pow(2, v, mod) - 1
now += pow(2, counter2[k], mod) - 1
ans = ans * now % mod
ans += zeroes
ans -= 1 # choose no fish
return ans % mod
if __name__ == "__main__":
print((main()))
|
from collections import defaultdict
import math
def main():
n = int(eval(input()))
mod = 1000000007
zeroes = 0
quadrant1 = defaultdict(int)
quadrant2 = defaultdict(int)
for _ in range(n):
a, b = list(map(int, input().split()))
if a == b == 0:
zeroes += 1
continue
g = math.gcd(a, b)
a, b = a // g, b // g
if b < 0:
a, b = -a, -b
if a <= 0:
a, b = b, -a
quadrant1[(a, b)] += 0
quadrant2[(a, b)] += 1
else:
quadrant1[(a, b)] += 1
quadrant2[(a, b)] += 0
ans = 1
for key, value in list(quadrant1.items()):
now = 1
now += pow(2, value, mod) - 1
now += pow(2, quadrant2[key], mod) - 1
ans = (ans * now) % mod
ans += zeroes - 1
return ans % mod
if __name__ == "__main__":
print((main()))
| false | 8.695652 |
[
"- counter1 = defaultdict(int)",
"- counter2 = defaultdict(int)",
"+ quadrant1 = defaultdict(int)",
"+ quadrant2 = defaultdict(int)",
"- x, y = [int(x) for x in input().split()]",
"- if x == y == 0:",
"+ a, b = list(map(int, input().split()))",
"+ if a == b == 0:",
"- denominator = math.gcd(x, y)",
"- x, y = x // denominator, y // denominator",
"- if y < 0:",
"- # quadrant III, IV -> I, II",
"- x, y = -x, -y",
"- if x <= 0:",
"- # round 90° from quadrant II to I",
"- x, y = y, -x",
"- counter2[(x, y)] += 1",
"- counter1[(x, y)] += 0",
"+ g = math.gcd(a, b)",
"+ a, b = a // g, b // g",
"+ if b < 0:",
"+ a, b = -a, -b",
"+ if a <= 0:",
"+ a, b = b, -a",
"+ quadrant1[(a, b)] += 0",
"+ quadrant2[(a, b)] += 1",
"- counter1[(x, y)] += 1",
"- counter2[(x, y)] += 0",
"+ quadrant1[(a, b)] += 1",
"+ quadrant2[(a, b)] += 0",
"- for k, v in list(counter1.items()):",
"+ for key, value in list(quadrant1.items()):",
"- now += pow(2, v, mod) - 1",
"- now += pow(2, counter2[k], mod) - 1",
"- ans = ans * now % mod",
"- ans += zeroes",
"- ans -= 1 # choose no fish",
"+ now += pow(2, value, mod) - 1",
"+ now += pow(2, quadrant2[key], mod) - 1",
"+ ans = (ans * now) % mod",
"+ ans += zeroes - 1"
] | false | 0.044713 | 0.044304 | 1.009239 |
[
"s304522526",
"s581799157"
] |
u788137651
|
p03363
|
python
|
s245520133
|
s590248085
| 864 | 161 | 102,480 | 44,032 |
Accepted
|
Accepted
| 81.37 |
from math import factorial
from itertools import accumulate
def combination(n, r): # n個からr個選ぶ場合の数
if n < r:
return 0
else:
return factorial(n)//(factorial(r) * factorial(n-r))
N = int(eval(input()))
A = [int(i) for i in input().split()]
ans = 0
cumsum = sorted(list(accumulate(A)))
now = None
cnt = 1
for a in cumsum:
if now is None:
now = a
elif now == a:
cnt += 1
else:
ans += combination(cnt, 2)
cnt = 1
now = a
ans += combination(cnt, 2)
ans += cumsum.count(0)
print(ans)
|
#
# ⋀_⋀
# (･ω･)
# .／ Ｕ ∽ Ｕ＼
# │＊ 合 ＊│
# │＊ 格 ＊│
# │＊ 祈 ＊│
# │＊ 願 ＊│
# │＊ ＊│
# ￣
#
import sys
sys.setrecursionlimit(10**6)
input=sys.stdin.readline
from math import floor,sqrt,factorial,hypot,log #log2ないｙｐ
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
from fractions import gcd
from random import randint
def ceil(a,b): return (a+b-1)//b
inf=float('inf')
mod = 10**9+7
def pprint(*A):
for a in A: print(*a,sep='\n')
def INT_(n): return int(n)-1
def MI(): return map(int,input().split())
def MF(): return map(float, input().split())
def MI_(): return map(INT_,input().split())
def LI(): return list(MI())
def LI_(): return [int(x) - 1 for x in input().split()]
def LF(): return list(MF())
def LIN(n:int): return [I() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]
def LLIN_(n: int): return [LI_() for _ in range(n)]
def LLI(): return [list(map(int, l.split() )) for l in input()]
def I(): return int(input())
def F(): return float(input())
def ST(): return input().replace('\n', '')
def main():
N=I()
A=LI()
*cumsum, = accumulate(A)
C=Counter(cumsum)
ans = C[0]
for v,c in C.items():
ans += c*(c-1)//2
print(ans)
if __name__ == '__main__':
main()
| 29 | 52 | 579 | 1,513 |
from math import factorial
from itertools import accumulate
def combination(n, r): # n個からr個選ぶ場合の数
if n < r:
return 0
else:
return factorial(n) // (factorial(r) * factorial(n - r))
N = int(eval(input()))
A = [int(i) for i in input().split()]
ans = 0
cumsum = sorted(list(accumulate(A)))
now = None
cnt = 1
for a in cumsum:
if now is None:
now = a
elif now == a:
cnt += 1
else:
ans += combination(cnt, 2)
cnt = 1
now = a
ans += combination(cnt, 2)
ans += cumsum.count(0)
print(ans)
|
#
# ⋀_⋀
# (･ω･)
# .／ Ｕ ∽ Ｕ＼
# │＊ 合 ＊│
# │＊ 格 ＊│
# │＊ 祈 ＊│
# │＊ 願 ＊│
# │＊ ＊│
# ￣
#
import sys
sys.setrecursionlimit(10**6)
input = sys.stdin.readline
from math import floor, sqrt, factorial, hypot, log # log2ないｙｐ
from heapq import heappop, heappush, heappushpop
from collections import Counter, defaultdict, deque
from itertools import (
accumulate,
permutations,
combinations,
product,
combinations_with_replacement,
)
from bisect import bisect_left, bisect_right
from copy import deepcopy
from fractions import gcd
from random import randint
def ceil(a, b):
return (a + b - 1) // b
inf = float("inf")
mod = 10**9 + 7
def pprint(*A):
for a in A:
print(*a, sep="\n")
def INT_(n):
return int(n) - 1
def MI():
return map(int, input().split())
def MF():
return map(float, input().split())
def MI_():
return map(INT_, input().split())
def LI():
return list(MI())
def LI_():
return [int(x) - 1 for x in input().split()]
def LF():
return list(MF())
def LIN(n: int):
return [I() for _ in range(n)]
def LLIN(n: int):
return [LI() for _ in range(n)]
def LLIN_(n: int):
return [LI_() for _ in range(n)]
def LLI():
return [list(map(int, l.split())) for l in input()]
def I():
return int(input())
def F():
return float(input())
def ST():
return input().replace("\n", "")
def main():
N = I()
A = LI()
(*cumsum,) = accumulate(A)
C = Counter(cumsum)
ans = C[0]
for v, c in C.items():
ans += c * (c - 1) // 2
print(ans)
if __name__ == "__main__":
main()
| false | 44.230769 |
[
"-from math import factorial",
"-from itertools import accumulate",
"+#",
"+# ⋀_⋀",
"+# (･ω･)",
"+# .／ Ｕ ∽ Ｕ＼",
"+# │＊ 合 ＊│",
"+# │＊ 格 ＊│",
"+# │＊ 祈 ＊│",
"+# │＊ 願 ＊│",
"+# │＊ ＊│",
"+# ￣",
"+#",
"+import sys",
"+",
"+sys.setrecursionlimit(10**6)",
"+input = sys.stdin.readline",
"+from math import floor, sqrt, factorial, hypot, log # log2ないｙｐ",
"+from heapq import heappop, heappush, heappushpop",
"+from collections import Counter, defaultdict, deque",
"+from itertools import (",
"+ accumulate,",
"+ permutations,",
"+ combinations,",
"+ product,",
"+ combinations_with_replacement,",
"+)",
"+from bisect import bisect_left, bisect_right",
"+from copy import deepcopy",
"+from fractions import gcd",
"+from random import randint",
"-def combination(n, r): # n個からr個選ぶ場合の数",
"- if n < r:",
"- return 0",
"- else:",
"- return factorial(n) // (factorial(r) * factorial(n - r))",
"+def ceil(a, b):",
"+ return (a + b - 1) // b",
"-N = int(eval(input()))",
"-A = [int(i) for i in input().split()]",
"-ans = 0",
"-cumsum = sorted(list(accumulate(A)))",
"-now = None",
"-cnt = 1",
"-for a in cumsum:",
"- if now is None:",
"- now = a",
"- elif now == a:",
"- cnt += 1",
"- else:",
"- ans += combination(cnt, 2)",
"- cnt = 1",
"- now = a",
"-ans += combination(cnt, 2)",
"-ans += cumsum.count(0)",
"-print(ans)",
"+inf = float(\"inf\")",
"+mod = 10**9 + 7",
"+",
"+",
"+def pprint(*A):",
"+ for a in A:",
"+ print(*a, sep=\"\\n\")",
"+",
"+",
"+def INT_(n):",
"+ return int(n) - 1",
"+",
"+",
"+def MI():",
"+ return map(int, input().split())",
"+",
"+",
"+def MF():",
"+ return map(float, input().split())",
"+",
"+",
"+def MI_():",
"+ return map(INT_, input().split())",
"+",
"+",
"+def LI():",
"+ return list(MI())",
"+",
"+",
"+def LI_():",
"+ return [int(x) - 1 for x in input().split()]",
"+",
"+",
"+def LF():",
"+ return list(MF())",
"+",
"+",
"+def LIN(n: int):",
"+ return [I() for _ in range(n)]",
"+",
"+",
"+def LLIN(n: int):",
"+ return [LI() for _ in range(n)]",
"+",
"+",
"+def LLIN_(n: int):",
"+ return [LI_() for _ in range(n)]",
"+",
"+",
"+def LLI():",
"+ return [list(map(int, l.split())) for l in input()]",
"+",
"+",
"+def I():",
"+ return int(input())",
"+",
"+",
"+def F():",
"+ return float(input())",
"+",
"+",
"+def ST():",
"+ return input().replace(\"\\n\", \"\")",
"+",
"+",
"+def main():",
"+ N = I()",
"+ A = LI()",
"+ (*cumsum,) = accumulate(A)",
"+ C = Counter(cumsum)",
"+ ans = C[0]",
"+ for v, c in C.items():",
"+ ans += c * (c - 1) // 2",
"+ print(ans)",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false | 0.037555 | 0.036301 | 1.034538 |
[
"s245520133",
"s590248085"
] |
u075012704
|
p03241
|
python
|
s205399001
|
s039623921
| 25 | 21 | 2,940 | 3,060 |
Accepted
|
Accepted
| 16 |
N, M = list(map(int, input().split()))
ans = 1
for g in range(1, int(M ** 0.5) + 1):
if M % g == 0 and M / g >= N:
ans = max(ans, g)
if M % g == 0:
g2 = M // g
if M % g2 == 0 and M / g2 >= N:
ans = max(ans, g2)
print(ans)
|
N, M = list(map(int, input().split()))
ans = 0
for x in range(1, int(M ** 0.5) + 1):
if M % x != 0:
continue
else:
x1, x2 = x, M // x
if M // x1 >= N:
ans = max(ans, x1)
if M // x2 >= N:
ans = max(ans, x2)
print(ans)
| 12 | 14 | 277 | 290 |
N, M = list(map(int, input().split()))
ans = 1
for g in range(1, int(M**0.5) + 1):
if M % g == 0 and M / g >= N:
ans = max(ans, g)
if M % g == 0:
g2 = M // g
if M % g2 == 0 and M / g2 >= N:
ans = max(ans, g2)
print(ans)
|
N, M = list(map(int, input().split()))
ans = 0
for x in range(1, int(M**0.5) + 1):
if M % x != 0:
continue
else:
x1, x2 = x, M // x
if M // x1 >= N:
ans = max(ans, x1)
if M // x2 >= N:
ans = max(ans, x2)
print(ans)
| false | 14.285714 |
[
"-ans = 1",
"-for g in range(1, int(M**0.5) + 1):",
"- if M % g == 0 and M / g >= N:",
"- ans = max(ans, g)",
"- if M % g == 0:",
"- g2 = M // g",
"- if M % g2 == 0 and M / g2 >= N:",
"- ans = max(ans, g2)",
"+ans = 0",
"+for x in range(1, int(M**0.5) + 1):",
"+ if M % x != 0:",
"+ continue",
"+ else:",
"+ x1, x2 = x, M // x",
"+ if M // x1 >= N:",
"+ ans = max(ans, x1)",
"+ if M // x2 >= N:",
"+ ans = max(ans, x2)"
] | false | 0.127163 | 0.038572 | 3.296791 |
[
"s205399001",
"s039623921"
] |
u197300260
|
p03331
|
python
|
s650966871
|
s501306421
| 331 | 17 | 3,064 | 3,064 |
Accepted
|
Accepted
| 94.86 |
# Problem: https://atcoder.jp/contests/agc025/tasks/agc025_a
# Python 2nd Try
import sys
# from collections import defaultdict
# import heapq,copy
# from collections import deque
def II(): return int(sys.stdin.readline())
def MI(): return list(map(int, sys.stdin.readline().split()))
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def solver(inputNo):
result = 36
for a in range(1, inputNo, +1):
strA = str(a)
strB = str(inputNo-a)
checkDigitAdd = 0
for j in range(0, len(strA)):
checkDigitAdd = checkDigitAdd + int(strA[j])
for j in range(0, len(strB)):
checkDigitAdd = checkDigitAdd + int(strB[j])
if checkDigitAdd < result:
result = checkDigitAdd
# print("Then {} {} , changed".format(strA, strB))
# algorithm
return result
if __name__ == "__main__":
print(("{}".format(solver(II()))))
|
# Problem: https://atcoder.jp/contests/agc025/tasks/agc025_a
# Python 3rd Try
import sys
# from collections import defaultdict
# import heapq,copy
# from collections import deque
def II(): return int(sys.stdin.readline())
def MI(): return list(map(int, sys.stdin.readline().split()))
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def solver(inputNum):
result = 0
# algorithm
totalDigit = 0
inputStr = str(inputNum)
for j in range(0, len(inputStr)):
totalDigit = totalDigit + int(inputStr[j])
if totalDigit == 1:
result = 10
else:
result = totalDigit
return result
if __name__ == "__main__":
print(("{}".format(solver(II()))))
| 40 | 37 | 1,027 | 807 |
# Problem: https://atcoder.jp/contests/agc025/tasks/agc025_a
# Python 2nd Try
import sys
# from collections import defaultdict
# import heapq,copy
# from collections import deque
def II():
return int(sys.stdin.readline())
def MI():
return list(map(int, sys.stdin.readline().split()))
def LI():
return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number):
return [LI() for _ in range(rows_number)]
def solver(inputNo):
result = 36
for a in range(1, inputNo, +1):
strA = str(a)
strB = str(inputNo - a)
checkDigitAdd = 0
for j in range(0, len(strA)):
checkDigitAdd = checkDigitAdd + int(strA[j])
for j in range(0, len(strB)):
checkDigitAdd = checkDigitAdd + int(strB[j])
if checkDigitAdd < result:
result = checkDigitAdd
# print("Then {} {} , changed".format(strA, strB))
# algorithm
return result
if __name__ == "__main__":
print(("{}".format(solver(II()))))
|
# Problem: https://atcoder.jp/contests/agc025/tasks/agc025_a
# Python 3rd Try
import sys
# from collections import defaultdict
# import heapq,copy
# from collections import deque
def II():
return int(sys.stdin.readline())
def MI():
return list(map(int, sys.stdin.readline().split()))
def LI():
return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number):
return [LI() for _ in range(rows_number)]
def solver(inputNum):
result = 0
# algorithm
totalDigit = 0
inputStr = str(inputNum)
for j in range(0, len(inputStr)):
totalDigit = totalDigit + int(inputStr[j])
if totalDigit == 1:
result = 10
else:
result = totalDigit
return result
if __name__ == "__main__":
print(("{}".format(solver(II()))))
| false | 7.5 |
[
"-# Python 2nd Try",
"+# Python 3rd Try",
"-def solver(inputNo):",
"- result = 36",
"- for a in range(1, inputNo, +1):",
"- strA = str(a)",
"- strB = str(inputNo - a)",
"- checkDigitAdd = 0",
"- for j in range(0, len(strA)):",
"- checkDigitAdd = checkDigitAdd + int(strA[j])",
"- for j in range(0, len(strB)):",
"- checkDigitAdd = checkDigitAdd + int(strB[j])",
"- if checkDigitAdd < result:",
"- result = checkDigitAdd",
"- # print(\"Then {} {} , changed\".format(strA, strB))",
"+def solver(inputNum):",
"+ result = 0",
"+ totalDigit = 0",
"+ inputStr = str(inputNum)",
"+ for j in range(0, len(inputStr)):",
"+ totalDigit = totalDigit + int(inputStr[j])",
"+ if totalDigit == 1:",
"+ result = 10",
"+ else:",
"+ result = totalDigit"
] | false | 0.304156 | 0.03586 | 8.481669 |
[
"s650966871",
"s501306421"
] |
u395202850
|
p03435
|
python
|
s564928759
|
s395738386
| 21 | 18 | 3,064 | 3,060 |
Accepted
|
Accepted
| 14.29 |
c = [list(map(int, input().split())) for i in range(3)]
q1 = c[0][0] - c[0][1] == c[1][0] - c[1][1] == c[2][0] - c[2][1]
q2 = c[0][0] - c[0][2] == c[1][0] - c[1][2] == c[2][0] - c[2][2]
q3 = c[0][0] - c[1][0] == c[0][1] - c[1][1] == c[0][2] - c[1][2]
q4 = c[0][0] - c[2][0] == c[0][1] - c[2][1] == c[0][2] - c[2][2]
print(("Yes" if q1 and q2 and q3 and q4 else "No"))
|
[(a, b, c), (d, e, f), (g, h, i)] = [
list(map(int, input().split())) for i in range(3)]
q1 = a - b == d - e== g - h
q2 = a - c == d - f == g - i
q3 = a - d == b - e== c - f
q4 = a - g == b - h == c - i
print(("Yes" if q1 and q2 and q3 and q4 else "No"))
| 8 | 9 | 375 | 261 |
c = [list(map(int, input().split())) for i in range(3)]
q1 = c[0][0] - c[0][1] == c[1][0] - c[1][1] == c[2][0] - c[2][1]
q2 = c[0][0] - c[0][2] == c[1][0] - c[1][2] == c[2][0] - c[2][2]
q3 = c[0][0] - c[1][0] == c[0][1] - c[1][1] == c[0][2] - c[1][2]
q4 = c[0][0] - c[2][0] == c[0][1] - c[2][1] == c[0][2] - c[2][2]
print(("Yes" if q1 and q2 and q3 and q4 else "No"))
|
[(a, b, c), (d, e, f), (g, h, i)] = [list(map(int, input().split())) for i in range(3)]
q1 = a - b == d - e == g - h
q2 = a - c == d - f == g - i
q3 = a - d == b - e == c - f
q4 = a - g == b - h == c - i
print(("Yes" if q1 and q2 and q3 and q4 else "No"))
| false | 11.111111 |
[
"-c = [list(map(int, input().split())) for i in range(3)]",
"-q1 = c[0][0] - c[0][1] == c[1][0] - c[1][1] == c[2][0] - c[2][1]",
"-q2 = c[0][0] - c[0][2] == c[1][0] - c[1][2] == c[2][0] - c[2][2]",
"-q3 = c[0][0] - c[1][0] == c[0][1] - c[1][1] == c[0][2] - c[1][2]",
"-q4 = c[0][0] - c[2][0] == c[0][1] - c[2][1] == c[0][2] - c[2][2]",
"+[(a, b, c), (d, e, f), (g, h, i)] = [list(map(int, input().split())) for i in range(3)]",
"+q1 = a - b == d - e == g - h",
"+q2 = a - c == d - f == g - i",
"+q3 = a - d == b - e == c - f",
"+q4 = a - g == b - h == c - i"
] | false | 0.090551 | 0.04478 | 2.022137 |
[
"s564928759",
"s395738386"
] |
u813450984
|
p03624
|
python
|
s794872407
|
s991109816
| 20 | 17 | 3,188 | 3,188 |
Accepted
|
Accepted
| 15 |
S = eval(input())
alphabet = "abcdefghijklmnopqrstuvwxyz"
found = [i for i in alphabet if i not in S]
found.sort()
if len(found) == 0:
print('None')
else:
print((found[0]))
|
S = eval(input())
alphabet = "abcdefghijklmnopqrstuvwxyz"
found = False
for i in alphabet:
if i not in S:
print(i)
found = True
break
if not found:
print('None')
| 8 | 11 | 175 | 184 |
S = eval(input())
alphabet = "abcdefghijklmnopqrstuvwxyz"
found = [i for i in alphabet if i not in S]
found.sort()
if len(found) == 0:
print("None")
else:
print((found[0]))
|
S = eval(input())
alphabet = "abcdefghijklmnopqrstuvwxyz"
found = False
for i in alphabet:
if i not in S:
print(i)
found = True
break
if not found:
print("None")
| false | 27.272727 |
[
"-found = [i for i in alphabet if i not in S]",
"-found.sort()",
"-if len(found) == 0:",
"+found = False",
"+for i in alphabet:",
"+ if i not in S:",
"+ print(i)",
"+ found = True",
"+ break",
"+if not found:",
"-else:",
"- print((found[0]))"
] | false | 0.043101 | 0.063275 | 0.68116 |
[
"s794872407",
"s991109816"
] |
u930705402
|
p03450
|
python
|
s552676699
|
s050373857
| 1,769 | 1,167 | 10,656 | 81,056 |
Accepted
|
Accepted
| 34.03 |
def root(x):
if(par[x]==x):
return x
else:
r=root(par[x])
diff_weight[x]+=diff_weight[par[x]]
par[x]=r
return r
def weight(x):
root(x)
return diff_weight[x]
def diff(x,y):
return weight(y)-weight(x)
def relate(a,b,w):
w+=weight(a);w-=weight(b)
a=root(a)
b=root(b)
if(a==b):
return False
if rank[a]<rank[b]:
a,b=b,a
w=-w
if rank[a]==rank[b]:
rank[b]+=1
par[b]=a
par[b]=a
diff_weight[b]=w
siz[a]+=siz[b]
return True
def size(a):
return siz[root(a)]
def same(a,b):
return root(a)==root(b)
N,M=list(map(int,input().split()))
par=[i for i in range(N)]
siz=[1 for _ in range(N)]
rank=[0 for _ in range(N)]
diff_weight=[0 for _ in range(N)]
for i in range(M):
L,R,D=list(map(int,input().split()))
L,R=L-1,R-1
if same(L,R) and diff(L,R)!=D:
print('No')
exit()
else:
relate(L,R,D)
print('Yes')
|
from collections import deque
N,M=list(map(int,input().split()))
G=[[] for i in range(N)]
for i in range(M):
L,R,D=list(map(int,input().split()))
L,R=L-1,R-1
G[L].append((D,R))
G[R].append((-D,L))
ok=True
dist=[None]*N
que=deque()
for i in range(N):
if dist[i]!=None:
continue
que.append(i)
dist[i]=0
while que:
v=que.popleft()
for cost,nv in G[v]:
if dist[nv]!=None:
if dist[nv]!=dist[v]+cost:
print('No')
exit()
else:
dist[nv]=dist[v]+cost
que.append(nv)
print('Yes')
| 54 | 29 | 1,028 | 655 |
def root(x):
if par[x] == x:
return x
else:
r = root(par[x])
diff_weight[x] += diff_weight[par[x]]
par[x] = r
return r
def weight(x):
root(x)
return diff_weight[x]
def diff(x, y):
return weight(y) - weight(x)
def relate(a, b, w):
w += weight(a)
w -= weight(b)
a = root(a)
b = root(b)
if a == b:
return False
if rank[a] < rank[b]:
a, b = b, a
w = -w
if rank[a] == rank[b]:
rank[b] += 1
par[b] = a
par[b] = a
diff_weight[b] = w
siz[a] += siz[b]
return True
def size(a):
return siz[root(a)]
def same(a, b):
return root(a) == root(b)
N, M = list(map(int, input().split()))
par = [i for i in range(N)]
siz = [1 for _ in range(N)]
rank = [0 for _ in range(N)]
diff_weight = [0 for _ in range(N)]
for i in range(M):
L, R, D = list(map(int, input().split()))
L, R = L - 1, R - 1
if same(L, R) and diff(L, R) != D:
print("No")
exit()
else:
relate(L, R, D)
print("Yes")
|
from collections import deque
N, M = list(map(int, input().split()))
G = [[] for i in range(N)]
for i in range(M):
L, R, D = list(map(int, input().split()))
L, R = L - 1, R - 1
G[L].append((D, R))
G[R].append((-D, L))
ok = True
dist = [None] * N
que = deque()
for i in range(N):
if dist[i] != None:
continue
que.append(i)
dist[i] = 0
while que:
v = que.popleft()
for cost, nv in G[v]:
if dist[nv] != None:
if dist[nv] != dist[v] + cost:
print("No")
exit()
else:
dist[nv] = dist[v] + cost
que.append(nv)
print("Yes")
| false | 46.296296 |
[
"-def root(x):",
"- if par[x] == x:",
"- return x",
"- else:",
"- r = root(par[x])",
"- diff_weight[x] += diff_weight[par[x]]",
"- par[x] = r",
"- return r",
"-",
"-",
"-def weight(x):",
"- root(x)",
"- return diff_weight[x]",
"-",
"-",
"-def diff(x, y):",
"- return weight(y) - weight(x)",
"-",
"-",
"-def relate(a, b, w):",
"- w += weight(a)",
"- w -= weight(b)",
"- a = root(a)",
"- b = root(b)",
"- if a == b:",
"- return False",
"- if rank[a] < rank[b]:",
"- a, b = b, a",
"- w = -w",
"- if rank[a] == rank[b]:",
"- rank[b] += 1",
"- par[b] = a",
"- par[b] = a",
"- diff_weight[b] = w",
"- siz[a] += siz[b]",
"- return True",
"-",
"-",
"-def size(a):",
"- return siz[root(a)]",
"-",
"-",
"-def same(a, b):",
"- return root(a) == root(b)",
"-",
"+from collections import deque",
"-par = [i for i in range(N)]",
"-siz = [1 for _ in range(N)]",
"-rank = [0 for _ in range(N)]",
"-diff_weight = [0 for _ in range(N)]",
"+G = [[] for i in range(N)]",
"- if same(L, R) and diff(L, R) != D:",
"- print(\"No\")",
"- exit()",
"- else:",
"- relate(L, R, D)",
"+ G[L].append((D, R))",
"+ G[R].append((-D, L))",
"+ok = True",
"+dist = [None] * N",
"+que = deque()",
"+for i in range(N):",
"+ if dist[i] != None:",
"+ continue",
"+ que.append(i)",
"+ dist[i] = 0",
"+ while que:",
"+ v = que.popleft()",
"+ for cost, nv in G[v]:",
"+ if dist[nv] != None:",
"+ if dist[nv] != dist[v] + cost:",
"+ print(\"No\")",
"+ exit()",
"+ else:",
"+ dist[nv] = dist[v] + cost",
"+ que.append(nv)"
] | false | 0.19249 | 0.086133 | 2.234808 |
[
"s552676699",
"s050373857"
] |
u981931040
|
p03352
|
python
|
s773348632
|
s323479182
| 182 | 18 | 38,256 | 3,064 |
Accepted
|
Accepted
| 90.11 |
X = int(eval(input()))
ans = 1
for b in range(2,X):
for p in range(2,X):
tmp_ans = b ** p
if tmp_ans > X:
break
if tmp_ans > ans:
ans = tmp_ans
print(ans)
|
X = int(eval(input()))
ans = 1
for b in range(1, X):
for p in range(2, X):
tmp = b ** p
if tmp > X:
break
if ans < tmp:
ans = tmp
print(ans)
| 10 | 10 | 209 | 195 |
X = int(eval(input()))
ans = 1
for b in range(2, X):
for p in range(2, X):
tmp_ans = b**p
if tmp_ans > X:
break
if tmp_ans > ans:
ans = tmp_ans
print(ans)
|
X = int(eval(input()))
ans = 1
for b in range(1, X):
for p in range(2, X):
tmp = b**p
if tmp > X:
break
if ans < tmp:
ans = tmp
print(ans)
| false | 0 |
[
"-for b in range(2, X):",
"+for b in range(1, X):",
"- tmp_ans = b**p",
"- if tmp_ans > X:",
"+ tmp = b**p",
"+ if tmp > X:",
"- if tmp_ans > ans:",
"- ans = tmp_ans",
"+ if ans < tmp:",
"+ ans = tmp"
] | false | 0.104268 | 0.043666 | 2.387862 |
[
"s773348632",
"s323479182"
] |
u246217175
|
p02862
|
python
|
s717745282
|
s055384223
| 286 | 207 | 101,996 | 41,196 |
Accepted
|
Accepted
| 27.62 |
#ABC145D
MOD = 10 ** 9 + 7
import math
x,y = list(map(int,input().split()))
a,b = -1,-1
for i in range(x+1):
m = 0
if (x-i) % 2 == 0:
m = (x-i) // 2
if 2*i + m == y:
if i >= 0 and m >= 0:
a = i
b = m
break
else:
continue
MAX_N = 10**6
fact = [1]
fact_inv = [0]*(MAX_N+4)
for i in range(MAX_N+3):
fact.append(fact[-1]*(i+1)%MOD)
fact_inv[-1] = pow(fact[-1],MOD-2,MOD)
for i in range(MAX_N+2,-1,-1):
fact_inv[i] = fact_inv[i+1]*(i+1)%MOD
def com(n,k,mod):
return fact[n] * fact_inv[k] % mod * fact_inv[n-k] %mod
if a == -1 and b == -1:
print((0))
else:
print((com(a+b,a,MOD)))
|
#ABC145D
MOD = 10 ** 9 + 7
import math
x,y = list(map(int,input().split()))
a,b = -1,-1
for i in range(x+1):
m = 0
if (x-i) % 2 == 0:
m = (x-i) // 2
if 2*i + m == y:
if i >= 0 and m >= 0:
a = i
b = m
break
else:
continue
def kai(x):
an = 1
for i in range(1,x+1):
an = an * i % MOD
return an
def pow_k(x, n):
if n == 0:
return 1
K = 1
while n > 1:
if n % 2 != 0:
K = K * x % MOD
x = x ** 2 % MOD
n //= 2
return K * x % MOD
al = kai(a)
be = kai(b)
if a == -1 and b == -1:
print((0))
else:
print((( kai(a+b) * pow_k(al,MOD-2)) % MOD * pow_k(be,MOD-2) % MOD ))
| 38 | 46 | 751 | 800 |
# ABC145D
MOD = 10**9 + 7
import math
x, y = list(map(int, input().split()))
a, b = -1, -1
for i in range(x + 1):
m = 0
if (x - i) % 2 == 0:
m = (x - i) // 2
if 2 * i + m == y:
if i >= 0 and m >= 0:
a = i
b = m
break
else:
continue
MAX_N = 10**6
fact = [1]
fact_inv = [0] * (MAX_N + 4)
for i in range(MAX_N + 3):
fact.append(fact[-1] * (i + 1) % MOD)
fact_inv[-1] = pow(fact[-1], MOD - 2, MOD)
for i in range(MAX_N + 2, -1, -1):
fact_inv[i] = fact_inv[i + 1] * (i + 1) % MOD
def com(n, k, mod):
return fact[n] * fact_inv[k] % mod * fact_inv[n - k] % mod
if a == -1 and b == -1:
print((0))
else:
print((com(a + b, a, MOD)))
|
# ABC145D
MOD = 10**9 + 7
import math
x, y = list(map(int, input().split()))
a, b = -1, -1
for i in range(x + 1):
m = 0
if (x - i) % 2 == 0:
m = (x - i) // 2
if 2 * i + m == y:
if i >= 0 and m >= 0:
a = i
b = m
break
else:
continue
def kai(x):
an = 1
for i in range(1, x + 1):
an = an * i % MOD
return an
def pow_k(x, n):
if n == 0:
return 1
K = 1
while n > 1:
if n % 2 != 0:
K = K * x % MOD
x = x**2 % MOD
n //= 2
return K * x % MOD
al = kai(a)
be = kai(b)
if a == -1 and b == -1:
print((0))
else:
print(((kai(a + b) * pow_k(al, MOD - 2)) % MOD * pow_k(be, MOD - 2) % MOD))
| false | 17.391304 |
[
"-MAX_N = 10**6",
"-fact = [1]",
"-fact_inv = [0] * (MAX_N + 4)",
"-for i in range(MAX_N + 3):",
"- fact.append(fact[-1] * (i + 1) % MOD)",
"-fact_inv[-1] = pow(fact[-1], MOD - 2, MOD)",
"-for i in range(MAX_N + 2, -1, -1):",
"- fact_inv[i] = fact_inv[i + 1] * (i + 1) % MOD",
"-def com(n, k, mod):",
"- return fact[n] * fact_inv[k] % mod * fact_inv[n - k] % mod",
"+def kai(x):",
"+ an = 1",
"+ for i in range(1, x + 1):",
"+ an = an * i % MOD",
"+ return an",
"+def pow_k(x, n):",
"+ if n == 0:",
"+ return 1",
"+ K = 1",
"+ while n > 1:",
"+ if n % 2 != 0:",
"+ K = K * x % MOD",
"+ x = x**2 % MOD",
"+ n //= 2",
"+ return K * x % MOD",
"+",
"+",
"+al = kai(a)",
"+be = kai(b)",
"- print((com(a + b, a, MOD)))",
"+ print(((kai(a + b) * pow_k(al, MOD - 2)) % MOD * pow_k(be, MOD - 2) % MOD))"
] | false | 1.28334 | 0.168265 | 7.626907 |
[
"s717745282",
"s055384223"
] |
u083960235
|
p02754
|
python
|
s413618935
|
s857816153
| 39 | 27 | 5,192 | 3,944 |
Accepted
|
Accepted
| 30.77 |
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd
def input(): return sys.stdin.readline().strip()
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def S_MAP(): return list(map(str, input().split()))
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
n, a, b = MAP()
# x = n // (a + b)
# pr/int(x)
x = 0
x = (n // (a + b)) * a
y = 0
if a != 0:
y = n % (a+b)
if not 0 <= y <= a:
y = a
print((x + y))
|
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from heapq import heapify, heappop, heappush
def input(): return sys.stdin.readline().strip()
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def S_MAP(): return list(map(str, input().split()))
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
N, A, B = MAP()
a = N % (A + B)
b = N // (A + B)
c = 0
if 0 <= a <= A:
c = a
else:
c = A
print((b * A + c))
| 35 | 32 | 914 | 872 |
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd
def input():
return sys.stdin.readline().strip()
def INT():
return int(eval(input()))
def MAP():
return list(map(int, input().split()))
def S_MAP():
return list(map(str, input().split()))
def LIST():
return list(map(int, input().split()))
def S_LIST():
return list(map(str, input().split()))
sys.setrecursionlimit(10**9)
INF = float("inf")
mod = 10**9 + 7
n, a, b = MAP()
# x = n // (a + b)
# pr/int(x)
x = 0
x = (n // (a + b)) * a
y = 0
if a != 0:
y = n % (a + b)
if not 0 <= y <= a:
y = a
print((x + y))
|
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from heapq import heapify, heappop, heappush
def input():
return sys.stdin.readline().strip()
def INT():
return int(eval(input()))
def MAP():
return list(map(int, input().split()))
def S_MAP():
return list(map(str, input().split()))
def LIST():
return list(map(int, input().split()))
def S_LIST():
return list(map(str, input().split()))
sys.setrecursionlimit(10**9)
INF = float("inf")
mod = 10**9 + 7
N, A, B = MAP()
a = N % (A + B)
b = N // (A + B)
c = 0
if 0 <= a <= A:
c = a
else:
c = A
print((b * A + c))
| false | 8.571429 |
[
"-from fractions import gcd",
"+from heapq import heapify, heappop, heappush",
"-n, a, b = MAP()",
"-# x = n // (a + b)",
"-# pr/int(x)",
"-x = 0",
"-x = (n // (a + b)) * a",
"-y = 0",
"-if a != 0:",
"- y = n % (a + b)",
"- if not 0 <= y <= a:",
"- y = a",
"-print((x + y))",
"+N, A, B = MAP()",
"+a = N % (A + B)",
"+b = N // (A + B)",
"+c = 0",
"+if 0 <= a <= A:",
"+ c = a",
"+else:",
"+ c = A",
"+print((b * A + c))"
] | false | 0.035153 | 0.034801 | 1.010116 |
[
"s413618935",
"s857816153"
] |
u726872801
|
p02603
|
python
|
s551071317
|
s633780760
| 41 | 31 | 9,368 | 9,188 |
Accepted
|
Accepted
| 24.39 |
import sys
import heapq, math
from bisect import bisect_right
from itertools import zip_longest, permutations, combinations, combinations_with_replacement
from itertools import accumulate, dropwhile, takewhile, groupby
from functools import lru_cache
from copy import deepcopy
N = int(eval(input()))
A = list(map(int, input().split()))
B = [A[0]]
for i in range(1, N):
if A[i - 1] != A[i]:
B.append(A[i])
N = len(B)
def solve():
ret = 1000
l = 0
while l < N:
while l < N - 1 and B[l] > B[l + 1]:
l += 1
if l == N - 1:
return ret
C = [B[l]]
while l < N - 1 and B[l] < B[l + 1]:
C.append(B[l + 1])
l += 1
cnt = ret // C[0]
ret -= cnt * C[0]
ret += cnt * C[-1]
l += 1
return ret
print((solve()))
|
N = int(eval(input()))
A = list(map(int, input().split()))
i = 0
yen = 1000
while i < N:
while i < N - 1 and A[i] >= A[i + 1]:
i += 1
if i == N - 1:
break
x = i
while i < N - 1 and A[i] <= A[i + 1]:
i += 1
y = i
cnt = yen // A[x]
yen = yen - A[x] * cnt + A[y] * cnt
print(yen)
| 44 | 23 | 879 | 351 |
import sys
import heapq, math
from bisect import bisect_right
from itertools import (
zip_longest,
permutations,
combinations,
combinations_with_replacement,
)
from itertools import accumulate, dropwhile, takewhile, groupby
from functools import lru_cache
from copy import deepcopy
N = int(eval(input()))
A = list(map(int, input().split()))
B = [A[0]]
for i in range(1, N):
if A[i - 1] != A[i]:
B.append(A[i])
N = len(B)
def solve():
ret = 1000
l = 0
while l < N:
while l < N - 1 and B[l] > B[l + 1]:
l += 1
if l == N - 1:
return ret
C = [B[l]]
while l < N - 1 and B[l] < B[l + 1]:
C.append(B[l + 1])
l += 1
cnt = ret // C[0]
ret -= cnt * C[0]
ret += cnt * C[-1]
l += 1
return ret
print((solve()))
|
N = int(eval(input()))
A = list(map(int, input().split()))
i = 0
yen = 1000
while i < N:
while i < N - 1 and A[i] >= A[i + 1]:
i += 1
if i == N - 1:
break
x = i
while i < N - 1 and A[i] <= A[i + 1]:
i += 1
y = i
cnt = yen // A[x]
yen = yen - A[x] * cnt + A[y] * cnt
print(yen)
| false | 47.727273 |
[
"-import sys",
"-import heapq, math",
"-from bisect import bisect_right",
"-from itertools import (",
"- zip_longest,",
"- permutations,",
"- combinations,",
"- combinations_with_replacement,",
"-)",
"-from itertools import accumulate, dropwhile, takewhile, groupby",
"-from functools import lru_cache",
"-from copy import deepcopy",
"-",
"-B = [A[0]]",
"-for i in range(1, N):",
"- if A[i - 1] != A[i]:",
"- B.append(A[i])",
"-N = len(B)",
"-",
"-",
"-def solve():",
"- ret = 1000",
"- l = 0",
"- while l < N:",
"- while l < N - 1 and B[l] > B[l + 1]:",
"- l += 1",
"- if l == N - 1:",
"- return ret",
"- C = [B[l]]",
"- while l < N - 1 and B[l] < B[l + 1]:",
"- C.append(B[l + 1])",
"- l += 1",
"- cnt = ret // C[0]",
"- ret -= cnt * C[0]",
"- ret += cnt * C[-1]",
"- l += 1",
"- return ret",
"-",
"-",
"-print((solve()))",
"+i = 0",
"+yen = 1000",
"+while i < N:",
"+ while i < N - 1 and A[i] >= A[i + 1]:",
"+ i += 1",
"+ if i == N - 1:",
"+ break",
"+ x = i",
"+ while i < N - 1 and A[i] <= A[i + 1]:",
"+ i += 1",
"+ y = i",
"+ cnt = yen // A[x]",
"+ yen = yen - A[x] * cnt + A[y] * cnt",
"+print(yen)"
] | false | 0.189698 | 0.086082 | 2.203683 |
[
"s551071317",
"s633780760"
] |
u920103253
|
p03281
|
python
|
s280062109
|
s559695101
| 21 | 18 | 3,064 | 3,064 |
Accepted
|
Accepted
| 14.29 |
def n0():return int(eval(input()))
def n1():return [int(x) for x in input().split()]
def n2(n):return [int(eval(input())) for _ in range(n)]
def n3(n):return [[int(x) for x in input().split()] for _ in range(n)]
n=n0()
ans=0
for k in range(105,n+1,2):
c=0
for i in range(1,int(k**0.5)+1):
if k%i==0:
c+=2
if i**2==k:
c-=1
if c==8:
ans+=1
print(ans)
|
def n0():return int(eval(input()))
def n1():return [int(x) for x in input().split()]
def n2(n):return [int(eval(input())) for _ in range(n)]
def n3(n):return [[int(x) for x in input().split()] for _ in range(n)]
n=n0()
ans=0
for k in range(105,n+1,2):
c=0
for i in range(1,k+1):
if k%i==0:
c+=1
# if i**2==k:
# c-=1
if c==8:
ans+=1
print(ans)
| 18 | 18 | 407 | 401 |
def n0():
return int(eval(input()))
def n1():
return [int(x) for x in input().split()]
def n2(n):
return [int(eval(input())) for _ in range(n)]
def n3(n):
return [[int(x) for x in input().split()] for _ in range(n)]
n = n0()
ans = 0
for k in range(105, n + 1, 2):
c = 0
for i in range(1, int(k**0.5) + 1):
if k % i == 0:
c += 2
if i**2 == k:
c -= 1
if c == 8:
ans += 1
print(ans)
|
def n0():
return int(eval(input()))
def n1():
return [int(x) for x in input().split()]
def n2(n):
return [int(eval(input())) for _ in range(n)]
def n3(n):
return [[int(x) for x in input().split()] for _ in range(n)]
n = n0()
ans = 0
for k in range(105, n + 1, 2):
c = 0
for i in range(1, k + 1):
if k % i == 0:
c += 1
# if i**2==k:
# c-=1
if c == 8:
ans += 1
print(ans)
| false | 0 |
[
"- for i in range(1, int(k**0.5) + 1):",
"+ for i in range(1, k + 1):",
"- c += 2",
"- if i**2 == k:",
"- c -= 1",
"+ c += 1",
"+ # if i**2==k:",
"+ # c-=1"
] | false | 0.045664 | 0.046246 | 0.987411 |
[
"s280062109",
"s559695101"
] |
u606045429
|
p03946
|
python
|
s419852433
|
s759031369
| 115 | 101 | 20,832 | 20,832 |
Accepted
|
Accepted
| 12.17 |
from itertools import accumulate
N, T, *A = list(map(int, open(0).read().split()))
M = accumulate(A, min)
B = {}
for a, mi in zip(A, M):
b = a - mi
B[b] = B.get(b, 0) + 1
print((B[max(B.keys())]))
|
from itertools import accumulate
from collections import Counter
N, T, *A = list(map(int, open(0).read().split()))
M = accumulate(A, min)
B = Counter(a - mi for a, mi in zip(A, M))
print((B[max(B.keys())]))
| 11 | 9 | 210 | 210 |
from itertools import accumulate
N, T, *A = list(map(int, open(0).read().split()))
M = accumulate(A, min)
B = {}
for a, mi in zip(A, M):
b = a - mi
B[b] = B.get(b, 0) + 1
print((B[max(B.keys())]))
|
from itertools import accumulate
from collections import Counter
N, T, *A = list(map(int, open(0).read().split()))
M = accumulate(A, min)
B = Counter(a - mi for a, mi in zip(A, M))
print((B[max(B.keys())]))
| false | 18.181818 |
[
"+from collections import Counter",
"-B = {}",
"-for a, mi in zip(A, M):",
"- b = a - mi",
"- B[b] = B.get(b, 0) + 1",
"+B = Counter(a - mi for a, mi in zip(A, M))"
] | false | 0.043338 | 0.043308 | 1.000696 |
[
"s419852433",
"s759031369"
] |
u102275718
|
p03163
|
python
|
s462339776
|
s908446665
| 491 | 213 | 120,428 | 15,424 |
Accepted
|
Accepted
| 56.62 |
import sys
input = sys.stdin.readline
n, w = list(map(int, input().split()))
wv = [list(map(int, input().split())) for _ in range(n)]
dp = [[0]*(w+1) for _ in range(n)]
for i in range(wv[0][0], w+1):
dp[0][i] = wv[0][1]
for i in range(1, n):
for j in range(w+1):
if j-wv[i][0] < 0:
dp[i][j] = dp[i-1][j]
else:
dp[i][j] = max(dp[i-1][j], dp[i-1][j-wv[i][0]]+wv[i][1])
print((dp[n-1][w]))
|
import sys
input = sys.stdin.readline
import numpy as np
N, W = list(map(int, input().split()))
dp = np.zeros(W+1, dtype=int)
for i in range(N):
w, v = list(map(int, input().split()))
dp[w:] = np.maximum(dp[w:], dp[:-w]+v)
print((dp[-1]))
| 18 | 11 | 448 | 244 |
import sys
input = sys.stdin.readline
n, w = list(map(int, input().split()))
wv = [list(map(int, input().split())) for _ in range(n)]
dp = [[0] * (w + 1) for _ in range(n)]
for i in range(wv[0][0], w + 1):
dp[0][i] = wv[0][1]
for i in range(1, n):
for j in range(w + 1):
if j - wv[i][0] < 0:
dp[i][j] = dp[i - 1][j]
else:
dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - wv[i][0]] + wv[i][1])
print((dp[n - 1][w]))
|
import sys
input = sys.stdin.readline
import numpy as np
N, W = list(map(int, input().split()))
dp = np.zeros(W + 1, dtype=int)
for i in range(N):
w, v = list(map(int, input().split()))
dp[w:] = np.maximum(dp[w:], dp[:-w] + v)
print((dp[-1]))
| false | 38.888889 |
[
"-n, w = list(map(int, input().split()))",
"-wv = [list(map(int, input().split())) for _ in range(n)]",
"-dp = [[0] * (w + 1) for _ in range(n)]",
"-for i in range(wv[0][0], w + 1):",
"- dp[0][i] = wv[0][1]",
"-for i in range(1, n):",
"- for j in range(w + 1):",
"- if j - wv[i][0] < 0:",
"- dp[i][j] = dp[i - 1][j]",
"- else:",
"- dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - wv[i][0]] + wv[i][1])",
"-print((dp[n - 1][w]))",
"+import numpy as np",
"+",
"+N, W = list(map(int, input().split()))",
"+dp = np.zeros(W + 1, dtype=int)",
"+for i in range(N):",
"+ w, v = list(map(int, input().split()))",
"+ dp[w:] = np.maximum(dp[w:], dp[:-w] + v)",
"+print((dp[-1]))"
] | false | 0.074565 | 0.196748 | 0.37899 |
[
"s462339776",
"s908446665"
] |
u562935282
|
p03762
|
python
|
s605752618
|
s758456442
| 131 | 114 | 18,624 | 18,624 |
Accepted
|
Accepted
| 12.98 |
mod = 10 ** 9 + 7
def mod_mul(a, b):
return a * b % mod
N, M = list(map(int, input().split()))
*x, = list(map(int, input().split()))
*y, = list(map(int, input().split()))
sx = sum(mod_mul(_x, i - (N - 1 - i)) for i, _x in enumerate(x)) # _x * i - _x * (N - 1 - i)
sy = sum(mod_mul(_y, i - (M - 1 - i)) for i, _y in enumerate(y)) # _y * i - _y * (M - 1 - i)
print((sx * sy % mod))
|
def main():
MOD = 10 ** 9 + 7
N, M = list(map(int, input().split()))
*x, = list(map(int, input().split()))
*y, = list(map(int, input().split()))
sx = 0
for i, x_ in enumerate(x, 1):
sx = (sx + x_ * ((i - 1) - (N - i))) % MOD
sy = 0
for i, y_ in enumerate(y, 1):
sy = (sy + y_ * ((i - 1) - (M - i))) % MOD
ans = sx * sy % MOD
print(ans)
if __name__ == '__main__':
main()
# ある矩形の面積は
# (x1-x0)(y1-y0)
# x,yの各要素はx1,x0,y1,y0として何回出現するか?
# 1-indexedで、i番目の要素が
# x1として数えられるのは,
# 相方のx0の候補数 = 1-indexedのx0のインデックス = i-1
# x0として数えられるのは、
# 相方のx1の候補数 = 1-indexedのN-x0のインデックス = N-i
| 14 | 31 | 384 | 646 |
mod = 10**9 + 7
def mod_mul(a, b):
return a * b % mod
N, M = list(map(int, input().split()))
(*x,) = list(map(int, input().split()))
(*y,) = list(map(int, input().split()))
sx = sum(
mod_mul(_x, i - (N - 1 - i)) for i, _x in enumerate(x)
) # _x * i - _x * (N - 1 - i)
sy = sum(
mod_mul(_y, i - (M - 1 - i)) for i, _y in enumerate(y)
) # _y * i - _y * (M - 1 - i)
print((sx * sy % mod))
|
def main():
MOD = 10**9 + 7
N, M = list(map(int, input().split()))
(*x,) = list(map(int, input().split()))
(*y,) = list(map(int, input().split()))
sx = 0
for i, x_ in enumerate(x, 1):
sx = (sx + x_ * ((i - 1) - (N - i))) % MOD
sy = 0
for i, y_ in enumerate(y, 1):
sy = (sy + y_ * ((i - 1) - (M - i))) % MOD
ans = sx * sy % MOD
print(ans)
if __name__ == "__main__":
main()
# ある矩形の面積は
# (x1-x0)(y1-y0)
# x,yの各要素はx1,x0,y1,y0として何回出現するか?
# 1-indexedで、i番目の要素が
# x1として数えられるのは,
# 相方のx0の候補数 = 1-indexedのx0のインデックス = i-1
# x0として数えられるのは、
# 相方のx1の候補数 = 1-indexedのN-x0のインデックス = N-i
| false | 54.83871 |
[
"-mod = 10**9 + 7",
"+def main():",
"+ MOD = 10**9 + 7",
"+ N, M = list(map(int, input().split()))",
"+ (*x,) = list(map(int, input().split()))",
"+ (*y,) = list(map(int, input().split()))",
"+ sx = 0",
"+ for i, x_ in enumerate(x, 1):",
"+ sx = (sx + x_ * ((i - 1) - (N - i))) % MOD",
"+ sy = 0",
"+ for i, y_ in enumerate(y, 1):",
"+ sy = (sy + y_ * ((i - 1) - (M - i))) % MOD",
"+ ans = sx * sy % MOD",
"+ print(ans)",
"-def mod_mul(a, b):",
"- return a * b % mod",
"-",
"-",
"-N, M = list(map(int, input().split()))",
"-(*x,) = list(map(int, input().split()))",
"-(*y,) = list(map(int, input().split()))",
"-sx = sum(",
"- mod_mul(_x, i - (N - 1 - i)) for i, _x in enumerate(x)",
"-) # _x * i - _x * (N - 1 - i)",
"-sy = sum(",
"- mod_mul(_y, i - (M - 1 - i)) for i, _y in enumerate(y)",
"-) # _y * i - _y * (M - 1 - i)",
"-print((sx * sy % mod))",
"+if __name__ == \"__main__\":",
"+ main()",
"+# ある矩形の面積は",
"+# (x1-x0)(y1-y0)",
"+# x,yの各要素はx1,x0,y1,y0として何回出現するか?",
"+# 1-indexedで、i番目の要素が",
"+# x1として数えられるのは,",
"+# 相方のx0の候補数 = 1-indexedのx0のインデックス = i-1",
"+# x0として数えられるのは、",
"+# 相方のx1の候補数 = 1-indexedのN-x0のインデックス = N-i"
] | false | 0.070561 | 0.077669 | 0.908485 |
[
"s605752618",
"s758456442"
] |
u571969099
|
p02743
|
python
|
s743325898
|
s648792712
| 505 | 260 | 60,396 | 60,396 |
Accepted
|
Accepted
| 48.51 |
from decimal import *
getcontext().prec = 20000
a, b, c = [Decimal(int(i)) for i in input().split()]
if a.sqrt() + b.sqrt()-c.sqrt() < Decimal("-0."+"0"*10000+"1"):
print("Yes")
else:
print("No")
|
from decimal import *
a, b, c = [Decimal(int(i)) for i in input().split()]
if a.sqrt() + b.sqrt()-c.sqrt() < Decimal("-0."+"0"*20+"1"):
print("Yes")
else:
print("No")
| 7 | 6 | 210 | 180 |
from decimal import *
getcontext().prec = 20000
a, b, c = [Decimal(int(i)) for i in input().split()]
if a.sqrt() + b.sqrt() - c.sqrt() < Decimal("-0." + "0" * 10000 + "1"):
print("Yes")
else:
print("No")
|
from decimal import *
a, b, c = [Decimal(int(i)) for i in input().split()]
if a.sqrt() + b.sqrt() - c.sqrt() < Decimal("-0." + "0" * 20 + "1"):
print("Yes")
else:
print("No")
| false | 14.285714 |
[
"-getcontext().prec = 20000",
"-if a.sqrt() + b.sqrt() - c.sqrt() < Decimal(\"-0.\" + \"0\" * 10000 + \"1\"):",
"+if a.sqrt() + b.sqrt() - c.sqrt() < Decimal(\"-0.\" + \"0\" * 20 + \"1\"):"
] | false | 0.802207 | 0.03951 | 20.303775 |
[
"s743325898",
"s648792712"
] |
u057964173
|
p02773
|
python
|
s238161618
|
s866643186
| 624 | 551 | 35,700 | 47,664 |
Accepted
|
Accepted
| 11.7 |
from collections import Counter
def resolve():
n=int(eval(input()))
l=[eval(input()) for i in range(n)]
c=Counter(l)
maxl=[]
cntmax=max(c.values())
for name,kazu in list(c.items()):
if kazu==cntmax:
maxl.append(name)
maxl.sort()
for i in maxl:
print(i)
resolve()
|
import sys
def input(): return sys.stdin.readline().strip()
def resolve():
n=int(eval(input()))
l=[eval(input()) for i in range(n)]
from collections import Counter
c=Counter(l)
csort=c.most_common()
maxl=[]
for i in range(len(csort)):
if csort[i][1]==csort[0][1]:
maxl.append(csort[i][0])
maxl.sort()
for i in maxl:
print(i)
resolve()
| 14 | 17 | 317 | 403 |
from collections import Counter
def resolve():
n = int(eval(input()))
l = [eval(input()) for i in range(n)]
c = Counter(l)
maxl = []
cntmax = max(c.values())
for name, kazu in list(c.items()):
if kazu == cntmax:
maxl.append(name)
maxl.sort()
for i in maxl:
print(i)
resolve()
|
import sys
def input():
return sys.stdin.readline().strip()
def resolve():
n = int(eval(input()))
l = [eval(input()) for i in range(n)]
from collections import Counter
c = Counter(l)
csort = c.most_common()
maxl = []
for i in range(len(csort)):
if csort[i][1] == csort[0][1]:
maxl.append(csort[i][0])
maxl.sort()
for i in maxl:
print(i)
resolve()
| false | 17.647059 |
[
"-from collections import Counter",
"+import sys",
"+",
"+",
"+def input():",
"+ return sys.stdin.readline().strip()",
"+ from collections import Counter",
"+",
"+ csort = c.most_common()",
"- cntmax = max(c.values())",
"- for name, kazu in list(c.items()):",
"- if kazu == cntmax:",
"- maxl.append(name)",
"+ for i in range(len(csort)):",
"+ if csort[i][1] == csort[0][1]:",
"+ maxl.append(csort[i][0])"
] | false | 0.032171 | 0.033875 | 0.949708 |
[
"s238161618",
"s866643186"
] |
u884601206
|
p02971
|
python
|
s347411482
|
s284934250
| 554 | 510 | 14,176 | 12,532 |
Accepted
|
Accepted
| 7.94 |
N=int(eval(input()))
S=[int(eval(input())) for i in range(N)]
T=sorted(S,reverse=True)
for j in range(N):
if S[j]!=T[0]:
print((T[0]))
else:
print((T[1]))
|
n=int(eval(input()))
a=[int(eval(input())) for i in range(n)]
t=max(a)
s=a.index(t)
a.pop(s)
u=max(a)
for i in range(n):
if i==s:
print(u)
else:
print(t)
| 11 | 13 | 166 | 168 |
N = int(eval(input()))
S = [int(eval(input())) for i in range(N)]
T = sorted(S, reverse=True)
for j in range(N):
if S[j] != T[0]:
print((T[0]))
else:
print((T[1]))
|
n = int(eval(input()))
a = [int(eval(input())) for i in range(n)]
t = max(a)
s = a.index(t)
a.pop(s)
u = max(a)
for i in range(n):
if i == s:
print(u)
else:
print(t)
| false | 15.384615 |
[
"-N = int(eval(input()))",
"-S = [int(eval(input())) for i in range(N)]",
"-T = sorted(S, reverse=True)",
"-for j in range(N):",
"- if S[j] != T[0]:",
"- print((T[0]))",
"+n = int(eval(input()))",
"+a = [int(eval(input())) for i in range(n)]",
"+t = max(a)",
"+s = a.index(t)",
"+a.pop(s)",
"+u = max(a)",
"+for i in range(n):",
"+ if i == s:",
"+ print(u)",
"- print((T[1]))",
"+ print(t)"
] | false | 0.047919 | 0.045129 | 1.061828 |
[
"s347411482",
"s284934250"
] |
u638456847
|
p02987
|
python
|
s238215443
|
s498275932
| 23 | 17 | 3,316 | 2,940 |
Accepted
|
Accepted
| 26.09 |
from collections import Counter
s = eval(input())
t = Counter(s)
a = []
for i,j in list(t.items()):
a.append(j)
if len(a) == 2:
if a[0] == a[1]:
print("Yes")
exit()
print("No")
|
s = list(eval(input()))
s.sort()
if s[0] == s[1] and s[2] == s[3] and s[0] != s[2]:
print("Yes")
else:
print("No")
| 16 | 9 | 208 | 127 |
from collections import Counter
s = eval(input())
t = Counter(s)
a = []
for i, j in list(t.items()):
a.append(j)
if len(a) == 2:
if a[0] == a[1]:
print("Yes")
exit()
print("No")
|
s = list(eval(input()))
s.sort()
if s[0] == s[1] and s[2] == s[3] and s[0] != s[2]:
print("Yes")
else:
print("No")
| false | 43.75 |
[
"-from collections import Counter",
"-",
"-s = eval(input())",
"-t = Counter(s)",
"-a = []",
"-for i, j in list(t.items()):",
"- a.append(j)",
"-if len(a) == 2:",
"- if a[0] == a[1]:",
"- print(\"Yes\")",
"- exit()",
"-print(\"No\")",
"+s = list(eval(input()))",
"+s.sort()",
"+if s[0] == s[1] and s[2] == s[3] and s[0] != s[2]:",
"+ print(\"Yes\")",
"+else:",
"+ print(\"No\")"
] | false | 0.042023 | 0.085876 | 0.489347 |
[
"s238215443",
"s498275932"
] |
u439396449
|
p03487
|
python
|
s001345798
|
s154103811
| 116 | 89 | 18,676 | 18,676 |
Accepted
|
Accepted
| 23.28 |
from collections import defaultdict
N = int(eval(input()))
a = [int(x) for x in input().split()]
c = defaultdict(lambda: 0)
for a_i in a:
c[a_i] += 1
ans = 0
for i, j in list(c.items()):
if i > j:
ans += j
elif i < j:
ans += j - i
print(ans)
|
from collections import Counter
N = int(eval(input()))
a = [int(x) for x in input().split()]
c = Counter(a)
ans = 0
for k, v in list(c.items()):
if k < v:
ans += v - k
elif k > v:
ans += v
print(ans)
| 16 | 13 | 276 | 225 |
from collections import defaultdict
N = int(eval(input()))
a = [int(x) for x in input().split()]
c = defaultdict(lambda: 0)
for a_i in a:
c[a_i] += 1
ans = 0
for i, j in list(c.items()):
if i > j:
ans += j
elif i < j:
ans += j - i
print(ans)
|
from collections import Counter
N = int(eval(input()))
a = [int(x) for x in input().split()]
c = Counter(a)
ans = 0
for k, v in list(c.items()):
if k < v:
ans += v - k
elif k > v:
ans += v
print(ans)
| false | 18.75 |
[
"-from collections import defaultdict",
"+from collections import Counter",
"-c = defaultdict(lambda: 0)",
"-for a_i in a:",
"- c[a_i] += 1",
"+c = Counter(a)",
"-for i, j in list(c.items()):",
"- if i > j:",
"- ans += j",
"- elif i < j:",
"- ans += j - i",
"+for k, v in list(c.items()):",
"+ if k < v:",
"+ ans += v - k",
"+ elif k > v:",
"+ ans += v"
] | false | 0.077705 | 0.074636 | 1.041117 |
[
"s001345798",
"s154103811"
] |
u893063840
|
p03546
|
python
|
s272672856
|
s165063049
| 33 | 28 | 3,316 | 3,444 |
Accepted
|
Accepted
| 15.15 |
# -*- coding: utf-8 -*-
h, w = list(map(int, input().split()))
c = [list(map(int, input().split())) for _ in range(10)]
a = [list(map(int, input().split())) for _ in range(h)]
for k in range(10):
for i in range(10):
for j in range(10):
c[i][j] = min(c[i][j], c[i][k] + c[k][j])
ans = 0
for row in a:
for ele in row:
if ele == -1:
continue
else:
ans += c[ele][1]
print(ans)
|
def main():
h, w = list(map(int, input().split()))
c = [list(map(int, input().split())) for _ in range(10)]
a = [list(map(int, input().split())) for _ in range(h)]
dp = c.copy()
for k in range(10):
for i in range(10):
for j in range(10):
dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j])
magic = 0
for row in a:
for num in row:
if num == -1:
continue
magic += dp[num][1]
print(magic)
if __name__ == "__main__":
main()
| 20 | 24 | 458 | 557 |
# -*- coding: utf-8 -*-
h, w = list(map(int, input().split()))
c = [list(map(int, input().split())) for _ in range(10)]
a = [list(map(int, input().split())) for _ in range(h)]
for k in range(10):
for i in range(10):
for j in range(10):
c[i][j] = min(c[i][j], c[i][k] + c[k][j])
ans = 0
for row in a:
for ele in row:
if ele == -1:
continue
else:
ans += c[ele][1]
print(ans)
|
def main():
h, w = list(map(int, input().split()))
c = [list(map(int, input().split())) for _ in range(10)]
a = [list(map(int, input().split())) for _ in range(h)]
dp = c.copy()
for k in range(10):
for i in range(10):
for j in range(10):
dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j])
magic = 0
for row in a:
for num in row:
if num == -1:
continue
magic += dp[num][1]
print(magic)
if __name__ == "__main__":
main()
| false | 16.666667 |
[
"-# -*- coding: utf-8 -*-",
"-h, w = list(map(int, input().split()))",
"-c = [list(map(int, input().split())) for _ in range(10)]",
"-a = [list(map(int, input().split())) for _ in range(h)]",
"-for k in range(10):",
"- for i in range(10):",
"- for j in range(10):",
"- c[i][j] = min(c[i][j], c[i][k] + c[k][j])",
"-ans = 0",
"-for row in a:",
"- for ele in row:",
"- if ele == -1:",
"- continue",
"- else:",
"- ans += c[ele][1]",
"-print(ans)",
"+def main():",
"+ h, w = list(map(int, input().split()))",
"+ c = [list(map(int, input().split())) for _ in range(10)]",
"+ a = [list(map(int, input().split())) for _ in range(h)]",
"+ dp = c.copy()",
"+ for k in range(10):",
"+ for i in range(10):",
"+ for j in range(10):",
"+ dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j])",
"+ magic = 0",
"+ for row in a:",
"+ for num in row:",
"+ if num == -1:",
"+ continue",
"+ magic += dp[num][1]",
"+ print(magic)",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false | 0.043492 | 0.047776 | 0.910336 |
[
"s272672856",
"s165063049"
] |
u844646164
|
p02788
|
python
|
s664441801
|
s478875423
| 980 | 904 | 117,564 | 117,612 |
Accepted
|
Accepted
| 7.76 |
import math
from collections import deque
N, D, A = list(map(int, input().split()))
XH = [list(map(int, input().split())) for _ in range(N)]
XH = sorted(XH)
total = 0
D = 2*D
ans = 0
q = deque()
for x, h in XH:
while len(q) and q[0][0] < x:
total -= q.popleft()[1]
h -= total
if h > 0:
num = math.ceil(h/A)
ans += num
damage = num*A
total += damage
q += [[x+D, damage]]
print(ans)
|
import math
from collections import deque
N, D, A = list(map(int, input().split()))
XH = [list(map(int, input().split())) for _ in range(N)]
XH = sorted(XH)
ans = 0
total = 0
q = deque([])
for x, h in XH:
while q and q[0][0] < x:
total -= q.popleft()[1]
h -= total
if h <= 0:
continue
attack = math.ceil(h/A)
damage = attack*A
total += damage
q += [[x+2*D, damage]]
ans += attack
print(ans)
| 21 | 24 | 427 | 437 |
import math
from collections import deque
N, D, A = list(map(int, input().split()))
XH = [list(map(int, input().split())) for _ in range(N)]
XH = sorted(XH)
total = 0
D = 2 * D
ans = 0
q = deque()
for x, h in XH:
while len(q) and q[0][0] < x:
total -= q.popleft()[1]
h -= total
if h > 0:
num = math.ceil(h / A)
ans += num
damage = num * A
total += damage
q += [[x + D, damage]]
print(ans)
|
import math
from collections import deque
N, D, A = list(map(int, input().split()))
XH = [list(map(int, input().split())) for _ in range(N)]
XH = sorted(XH)
ans = 0
total = 0
q = deque([])
for x, h in XH:
while q and q[0][0] < x:
total -= q.popleft()[1]
h -= total
if h <= 0:
continue
attack = math.ceil(h / A)
damage = attack * A
total += damage
q += [[x + 2 * D, damage]]
ans += attack
print(ans)
| false | 12.5 |
[
"+ans = 0",
"-D = 2 * D",
"-ans = 0",
"-q = deque()",
"+q = deque([])",
"- while len(q) and q[0][0] < x:",
"+ while q and q[0][0] < x:",
"- if h > 0:",
"- num = math.ceil(h / A)",
"- ans += num",
"- damage = num * A",
"- total += damage",
"- q += [[x + D, damage]]",
"+ if h <= 0:",
"+ continue",
"+ attack = math.ceil(h / A)",
"+ damage = attack * A",
"+ total += damage",
"+ q += [[x + 2 * D, damage]]",
"+ ans += attack"
] | false | 0.085522 | 0.046675 | 1.832305 |
[
"s664441801",
"s478875423"
] |
u852690916
|
p03665
|
python
|
s691012067
|
s346372566
| 180 | 17 | 38,384 | 3,064 |
Accepted
|
Accepted
| 90.56 |
N,P=list(map(int, input().split()))
*A,=list(map(int, input().split()))
even=sum(1 for a in A if a&1==0)
odd =sum(1 for a in A if a&1==1)
def comb(n, r):
p, q = 1, 1
for i in range(min(r,n-r)):
p *= n-i
q *= i+1
return p // q
ans=0
for i in range(P,odd+1,2):
ans+=comb(odd, i)
ans *= 1<<even
print(ans)
|
N,P=list(map(int, input().split()))
*A,=list(map(int, input().split()))
odd=sum(1 for a in A if a&1)
if odd==0:
if P==1:
print((0))
else:
print((1<<N))
else:
print((1<<(N-1)))
| 19 | 10 | 344 | 194 |
N, P = list(map(int, input().split()))
(*A,) = list(map(int, input().split()))
even = sum(1 for a in A if a & 1 == 0)
odd = sum(1 for a in A if a & 1 == 1)
def comb(n, r):
p, q = 1, 1
for i in range(min(r, n - r)):
p *= n - i
q *= i + 1
return p // q
ans = 0
for i in range(P, odd + 1, 2):
ans += comb(odd, i)
ans *= 1 << even
print(ans)
|
N, P = list(map(int, input().split()))
(*A,) = list(map(int, input().split()))
odd = sum(1 for a in A if a & 1)
if odd == 0:
if P == 1:
print((0))
else:
print((1 << N))
else:
print((1 << (N - 1)))
| false | 47.368421 |
[
"-even = sum(1 for a in A if a & 1 == 0)",
"-odd = sum(1 for a in A if a & 1 == 1)",
"-",
"-",
"-def comb(n, r):",
"- p, q = 1, 1",
"- for i in range(min(r, n - r)):",
"- p *= n - i",
"- q *= i + 1",
"- return p // q",
"-",
"-",
"-ans = 0",
"-for i in range(P, odd + 1, 2):",
"- ans += comb(odd, i)",
"-ans *= 1 << even",
"-print(ans)",
"+odd = sum(1 for a in A if a & 1)",
"+if odd == 0:",
"+ if P == 1:",
"+ print((0))",
"+ else:",
"+ print((1 << N))",
"+else:",
"+ print((1 << (N - 1)))"
] | false | 0.066195 | 0.100456 | 0.658944 |
[
"s691012067",
"s346372566"
] |
u511824539
|
p04015
|
python
|
s928264355
|
s971608098
| 1,434 | 93 | 192,764 | 68,988 |
Accepted
|
Accepted
| 93.51 |
N, A = list(map(int, input().split()))
X = list([int(x)-A for x in input().split()])
X_MAX = max(max(X), -min(X))
NX = N * X_MAX
dp = [[[0] * (N+1) for i in range(N+1)] for _ in range(NX * 2 + 1)]
dp[NX][0][0] = 1
for i in range(1, N+1):
for j in range(0, i+1):
for k in range(NX * 2 + 1):
if k == NX and j == 0:
dp[k][i][j] = 1
continue
dp[k][i][j] += dp[k][i-1][j]
if 0 <= k - X[i-1] < NX * 2 + 1:
dp[k][i][j] += dp[k-X[i-1]][i-1][j-1]
print((sum(dp[NX][N]) - 1))
|
N, A = list(map(int, input().split()))
X = list([int(x)-A for x in input().split()])
X_MAX = max(max(X), -min(X))
NX = N * X_MAX
dp = [[0] * (X_MAX * (N+1) * 2 + 1) for i in range(N+1)]
dp [0][NX] = 1
for i in range(1, N+1):
for j in range(NX*2+1):
dp[i][j] += dp[i-1][j]
dp[i][j] += dp[i-1][j-X[i-1]]
print((dp[N][NX]-1))
| 17 | 12 | 576 | 352 |
N, A = list(map(int, input().split()))
X = list([int(x) - A for x in input().split()])
X_MAX = max(max(X), -min(X))
NX = N * X_MAX
dp = [[[0] * (N + 1) for i in range(N + 1)] for _ in range(NX * 2 + 1)]
dp[NX][0][0] = 1
for i in range(1, N + 1):
for j in range(0, i + 1):
for k in range(NX * 2 + 1):
if k == NX and j == 0:
dp[k][i][j] = 1
continue
dp[k][i][j] += dp[k][i - 1][j]
if 0 <= k - X[i - 1] < NX * 2 + 1:
dp[k][i][j] += dp[k - X[i - 1]][i - 1][j - 1]
print((sum(dp[NX][N]) - 1))
|
N, A = list(map(int, input().split()))
X = list([int(x) - A for x in input().split()])
X_MAX = max(max(X), -min(X))
NX = N * X_MAX
dp = [[0] * (X_MAX * (N + 1) * 2 + 1) for i in range(N + 1)]
dp[0][NX] = 1
for i in range(1, N + 1):
for j in range(NX * 2 + 1):
dp[i][j] += dp[i - 1][j]
dp[i][j] += dp[i - 1][j - X[i - 1]]
print((dp[N][NX] - 1))
| false | 29.411765 |
[
"-dp = [[[0] * (N + 1) for i in range(N + 1)] for _ in range(NX * 2 + 1)]",
"-dp[NX][0][0] = 1",
"+dp = [[0] * (X_MAX * (N + 1) * 2 + 1) for i in range(N + 1)]",
"+dp[0][NX] = 1",
"- for j in range(0, i + 1):",
"- for k in range(NX * 2 + 1):",
"- if k == NX and j == 0:",
"- dp[k][i][j] = 1",
"- continue",
"- dp[k][i][j] += dp[k][i - 1][j]",
"- if 0 <= k - X[i - 1] < NX * 2 + 1:",
"- dp[k][i][j] += dp[k - X[i - 1]][i - 1][j - 1]",
"-print((sum(dp[NX][N]) - 1))",
"+ for j in range(NX * 2 + 1):",
"+ dp[i][j] += dp[i - 1][j]",
"+ dp[i][j] += dp[i - 1][j - X[i - 1]]",
"+print((dp[N][NX] - 1))"
] | false | 0.116443 | 0.006502 | 17.909117 |
[
"s928264355",
"s971608098"
] |
u609061751
|
p03088
|
python
|
s122549861
|
s312227803
| 281 | 239 | 48,192 | 45,040 |
Accepted
|
Accepted
| 14.95 |
import sys
input = sys.stdin.readline
n = int(eval(input()))
dp = [[[[0]*4 for _ in range(4)] for _ in range(4)] for _ in range(n + 1)]
c = [0, 1, 2, 3]
import itertools
pers = itertools.product(c, repeat=3)
for p in pers:
if p in [(0, 1, 2), (0, 2, 1), (1, 0, 2)]:
continue
dp[3][p[0]][p[1]][p[2]] = 1
for i in range(4, n + 1):
for j in range(4):
for k in range(4):
for l in range(4):
if (j, k, l) in [(0, 1, 2), (0, 2, 1), (1, 0, 2)]:
continue
elif (j == 0 and l == 1) or (j == 0 and k == 1):
dp[i][j][k][l] = sum([dp[i - 1][k][l][x] for x in range(4) if x != 2])
else:
dp[i][j][k][l] = sum([dp[i - 1][k][l][x] for x in range(4)])
ans = 0
for j in range(4):
for k in range(4):
for l in range(4):
ans += dp[-1][j][k][l]
print((ans % (10**9 + 7)))
|
import sys
input = sys.stdin.readline
n = int(eval(input()))
dp = [[[[0]*4 for _ in range(4)] for _ in range(4)] for _ in range(n + 1)]
c = [0, 1, 2, 3]
import itertools
pers = itertools.product(c, repeat=3)
ng_3 = [(0, 1, 2), (0, 2, 1), (1, 0, 2)]
for p in pers:
if p in ng_3:
continue
dp[3][p[0]][p[1]][p[2]] = 1
for i in range(3, n):
for j in range(4):
for k in range(4):
for l in range(4):
for m in range(4):
if (m, j, k) in ng_3 or (m == 0 and k == 1 and l == 2) or (m == 0 and j == 1 and l == 2):
continue
dp[i + 1][m][j][k] += dp[i][j][k][l]
ans = 0
for j in range(4):
for k in range(4):
for l in range(4):
ans += dp[-1][j][k][l]
print((ans % (10**9 + 7)))
| 29 | 28 | 941 | 828 |
import sys
input = sys.stdin.readline
n = int(eval(input()))
dp = [[[[0] * 4 for _ in range(4)] for _ in range(4)] for _ in range(n + 1)]
c = [0, 1, 2, 3]
import itertools
pers = itertools.product(c, repeat=3)
for p in pers:
if p in [(0, 1, 2), (0, 2, 1), (1, 0, 2)]:
continue
dp[3][p[0]][p[1]][p[2]] = 1
for i in range(4, n + 1):
for j in range(4):
for k in range(4):
for l in range(4):
if (j, k, l) in [(0, 1, 2), (0, 2, 1), (1, 0, 2)]:
continue
elif (j == 0 and l == 1) or (j == 0 and k == 1):
dp[i][j][k][l] = sum(
[dp[i - 1][k][l][x] for x in range(4) if x != 2]
)
else:
dp[i][j][k][l] = sum([dp[i - 1][k][l][x] for x in range(4)])
ans = 0
for j in range(4):
for k in range(4):
for l in range(4):
ans += dp[-1][j][k][l]
print((ans % (10**9 + 7)))
|
import sys
input = sys.stdin.readline
n = int(eval(input()))
dp = [[[[0] * 4 for _ in range(4)] for _ in range(4)] for _ in range(n + 1)]
c = [0, 1, 2, 3]
import itertools
pers = itertools.product(c, repeat=3)
ng_3 = [(0, 1, 2), (0, 2, 1), (1, 0, 2)]
for p in pers:
if p in ng_3:
continue
dp[3][p[0]][p[1]][p[2]] = 1
for i in range(3, n):
for j in range(4):
for k in range(4):
for l in range(4):
for m in range(4):
if (
(m, j, k) in ng_3
or (m == 0 and k == 1 and l == 2)
or (m == 0 and j == 1 and l == 2)
):
continue
dp[i + 1][m][j][k] += dp[i][j][k][l]
ans = 0
for j in range(4):
for k in range(4):
for l in range(4):
ans += dp[-1][j][k][l]
print((ans % (10**9 + 7)))
| false | 3.448276 |
[
"+ng_3 = [(0, 1, 2), (0, 2, 1), (1, 0, 2)]",
"- if p in [(0, 1, 2), (0, 2, 1), (1, 0, 2)]:",
"+ if p in ng_3:",
"-for i in range(4, n + 1):",
"+for i in range(3, n):",
"- if (j, k, l) in [(0, 1, 2), (0, 2, 1), (1, 0, 2)]:",
"- continue",
"- elif (j == 0 and l == 1) or (j == 0 and k == 1):",
"- dp[i][j][k][l] = sum(",
"- [dp[i - 1][k][l][x] for x in range(4) if x != 2]",
"- )",
"- else:",
"- dp[i][j][k][l] = sum([dp[i - 1][k][l][x] for x in range(4)])",
"+ for m in range(4):",
"+ if (",
"+ (m, j, k) in ng_3",
"+ or (m == 0 and k == 1 and l == 2)",
"+ or (m == 0 and j == 1 and l == 2)",
"+ ):",
"+ continue",
"+ dp[i + 1][m][j][k] += dp[i][j][k][l]"
] | false | 0.088148 | 0.095515 | 0.922869 |
[
"s122549861",
"s312227803"
] |
u071693485
|
p00226
|
python
|
s385399854
|
s492509612
| 220 | 200 | 7,392 | 7,420 |
Accepted
|
Accepted
| 9.09 |
for q in range(12000):
a, b = input().split()
if a[0] is '0' and b[0] is '0':
break
hit = 0
for i in range(4):
if a[i] is b[i]:
hit = hit + 1
blow = 0
for j in range(4):
for i in range(4):
if (b[j] is a[i]) and (a[i] is not b[i]) and (a[j] is not b[j]):
blow = blow + 1
print((hit, blow))
|
for q in range(12000):
a, b = input().split()
if a[0] is '0' and b[0] is '0':
break
hit = sum(1 for c, d in zip(a, b) if d is c)
blow = sum(1 for e in b if e in a) - hit
print((hit, blow))
| 17 | 8 | 397 | 222 |
for q in range(12000):
a, b = input().split()
if a[0] is "0" and b[0] is "0":
break
hit = 0
for i in range(4):
if a[i] is b[i]:
hit = hit + 1
blow = 0
for j in range(4):
for i in range(4):
if (b[j] is a[i]) and (a[i] is not b[i]) and (a[j] is not b[j]):
blow = blow + 1
print((hit, blow))
|
for q in range(12000):
a, b = input().split()
if a[0] is "0" and b[0] is "0":
break
hit = sum(1 for c, d in zip(a, b) if d is c)
blow = sum(1 for e in b if e in a) - hit
print((hit, blow))
| false | 52.941176 |
[
"- hit = 0",
"- for i in range(4):",
"- if a[i] is b[i]:",
"- hit = hit + 1",
"- blow = 0",
"- for j in range(4):",
"- for i in range(4):",
"- if (b[j] is a[i]) and (a[i] is not b[i]) and (a[j] is not b[j]):",
"- blow = blow + 1",
"+ hit = sum(1 for c, d in zip(a, b) if d is c)",
"+ blow = sum(1 for e in b if e in a) - hit"
] | false | 0.138252 | 0.055397 | 2.495646 |
[
"s385399854",
"s492509612"
] |
u903005414
|
p02912
|
python
|
s224900430
|
s112409493
| 161 | 133 | 14,180 | 20,480 |
Accepted
|
Accepted
| 17.39 |
import heapq
n, m = list(map(int, input().split()))
a = list([int(x) * -1 for x in input().split()])
heapq.heapify(a)
for _ in range(m):
tmp = (heapq.heappop(a) * (-1)) // 2
heapq.heappush(a, -tmp)
print((sum(a) * -1))
|
from heapq import heapify, heappop, heappush
N, M = list(map(int, input().split()))
A = []
for i in input().split():
A.append(-int(i))
heapify(A)
for _ in range(M):
a = -heappop(A)
heappush(A, (a // 2) * -1)
# print('A', A)
ans = -sum(A)
print(ans)
| 8 | 13 | 231 | 268 |
import heapq
n, m = list(map(int, input().split()))
a = list([int(x) * -1 for x in input().split()])
heapq.heapify(a)
for _ in range(m):
tmp = (heapq.heappop(a) * (-1)) // 2
heapq.heappush(a, -tmp)
print((sum(a) * -1))
|
from heapq import heapify, heappop, heappush
N, M = list(map(int, input().split()))
A = []
for i in input().split():
A.append(-int(i))
heapify(A)
for _ in range(M):
a = -heappop(A)
heappush(A, (a // 2) * -1)
# print('A', A)
ans = -sum(A)
print(ans)
| false | 38.461538 |
[
"-import heapq",
"+from heapq import heapify, heappop, heappush",
"-n, m = list(map(int, input().split()))",
"-a = list([int(x) * -1 for x in input().split()])",
"-heapq.heapify(a)",
"-for _ in range(m):",
"- tmp = (heapq.heappop(a) * (-1)) // 2",
"- heapq.heappush(a, -tmp)",
"-print((sum(a) * -1))",
"+N, M = list(map(int, input().split()))",
"+A = []",
"+for i in input().split():",
"+ A.append(-int(i))",
"+heapify(A)",
"+for _ in range(M):",
"+ a = -heappop(A)",
"+ heappush(A, (a // 2) * -1)",
"+# print('A', A)",
"+ans = -sum(A)",
"+print(ans)"
] | false | 0.089515 | 0.048683 | 1.838736 |
[
"s224900430",
"s112409493"
] |
u998435601
|
p02416
|
python
|
s108175306
|
s219420488
| 20 | 10 | 6,436 | 6,436 |
Accepted
|
Accepted
| 50 |
# -*- coding: utf-8 -*-
while True:
s = input()
if s=="0": break
t = 0
for n in s:
t += int(n)
print(t)
|
while True:
s = input()
if s!="0": print(sum(map(int, s)))
else: break
| 8 | 4 | 120 | 79 |
# -*- coding: utf-8 -*-
while True:
s = input()
if s == "0":
break
t = 0
for n in s:
t += int(n)
print(t)
|
while True:
s = input()
if s != "0":
print(sum(map(int, s)))
else:
break
| false | 50 |
[
"-# -*- coding: utf-8 -*-",
"- if s == \"0\":",
"+ if s != \"0\":",
"+ print(sum(map(int, s)))",
"+ else:",
"- t = 0",
"- for n in s:",
"- t += int(n)",
"- print(t)"
] | false | 0.008164 | 0.035234 | 0.231718 |
[
"s108175306",
"s219420488"
] |
u179169725
|
p03043
|
python
|
s477547811
|
s047039783
| 50 | 46 | 6,296 | 3,436 |
Accepted
|
Accepted
| 8 |
# https://atcoder.jp/contests/abc126/tasks/abc126_c
N, K = list(map(int, input().split()))
probs = []
keisuu = 1 / N
for dice in range(1, N + 1):
score = dice
cnt = 0
while score < K:
score *= 2
cnt += 1
probs.append(keisuu * (1 / 2)**cnt)
print((sum(probs)))
|
import sys
sys.setrecursionlimit(1 << 25)
read = sys.stdin.readline
ra = range
enu = enumerate
def read_ints():
return list(map(int, read().split()))
def read_a_int():
return int(read())
def read_tuple(H):
'''
H is number of rows
'''
ret = []
for _ in range(H):
ret.append(tuple(map(int, read().split())))
return ret
def read_col(H):
'''
H is number of rows
A列、B列が与えられるようなとき
ex1)A,B=read_col(H) ex2) A,=read_col(H) #一列の場合
'''
ret = []
for _ in range(H):
ret.append(list(map(int, read().split())))
return tuple(map(list, list(zip(*ret))))
def read_matrix(H):
'''
H is number of rows
'''
ret = []
for _ in range(H):
ret.append(list(map(int, read().split())))
return ret
# return [list(map(int, read().split())) for _ in range(H)] # 内包表記はpypyでは遅いため
MOD = 10**9 + 7
INF = 2**31 # 2147483648 > 10**9
# default import
from collections import defaultdict, Counter, deque
from operator import itemgetter
from itertools import product, permutations, combinations
from bisect import bisect_left, bisect_right # , insort_left, insort_right
# https://atcoder.jp/contests/abc126/tasks/abc126_c
# 最初のサイコロでコインを最大何回降るか決まる
# 最大表が出続ける確率がすぬけくんの勝つ確率
# はじめにサイコロの確率も考慮したい
N, K = read_ints()
mul = 1 / N
ans = 0
for i in ra(1, N + 1):
n_coin = 0
prob_win = 1
while i < K:
i *= 2
prob_win /= 2
ans += prob_win
print((ans * mul))
| 15 | 72 | 307 | 1,535 |
# https://atcoder.jp/contests/abc126/tasks/abc126_c
N, K = list(map(int, input().split()))
probs = []
keisuu = 1 / N
for dice in range(1, N + 1):
score = dice
cnt = 0
while score < K:
score *= 2
cnt += 1
probs.append(keisuu * (1 / 2) ** cnt)
print((sum(probs)))
|
import sys
sys.setrecursionlimit(1 << 25)
read = sys.stdin.readline
ra = range
enu = enumerate
def read_ints():
return list(map(int, read().split()))
def read_a_int():
return int(read())
def read_tuple(H):
"""
H is number of rows
"""
ret = []
for _ in range(H):
ret.append(tuple(map(int, read().split())))
return ret
def read_col(H):
"""
H is number of rows
A列、B列が与えられるようなとき
ex1)A,B=read_col(H) ex2) A,=read_col(H) #一列の場合
"""
ret = []
for _ in range(H):
ret.append(list(map(int, read().split())))
return tuple(map(list, list(zip(*ret))))
def read_matrix(H):
"""
H is number of rows
"""
ret = []
for _ in range(H):
ret.append(list(map(int, read().split())))
return ret
# return [list(map(int, read().split())) for _ in range(H)] # 内包表記はpypyでは遅いため
MOD = 10**9 + 7
INF = 2**31 # 2147483648 > 10**9
# default import
from collections import defaultdict, Counter, deque
from operator import itemgetter
from itertools import product, permutations, combinations
from bisect import bisect_left, bisect_right # , insort_left, insort_right
# https://atcoder.jp/contests/abc126/tasks/abc126_c
# 最初のサイコロでコインを最大何回降るか決まる
# 最大表が出続ける確率がすぬけくんの勝つ確率
# はじめにサイコロの確率も考慮したい
N, K = read_ints()
mul = 1 / N
ans = 0
for i in ra(1, N + 1):
n_coin = 0
prob_win = 1
while i < K:
i *= 2
prob_win /= 2
ans += prob_win
print((ans * mul))
| false | 79.166667 |
[
"+import sys",
"+",
"+sys.setrecursionlimit(1 << 25)",
"+read = sys.stdin.readline",
"+ra = range",
"+enu = enumerate",
"+",
"+",
"+def read_ints():",
"+ return list(map(int, read().split()))",
"+",
"+",
"+def read_a_int():",
"+ return int(read())",
"+",
"+",
"+def read_tuple(H):",
"+ \"\"\"",
"+ H is number of rows",
"+ \"\"\"",
"+ ret = []",
"+ for _ in range(H):",
"+ ret.append(tuple(map(int, read().split())))",
"+ return ret",
"+",
"+",
"+def read_col(H):",
"+ \"\"\"",
"+ H is number of rows",
"+ A列、B列が与えられるようなとき",
"+ ex1)A,B=read_col(H) ex2) A,=read_col(H) #一列の場合",
"+ \"\"\"",
"+ ret = []",
"+ for _ in range(H):",
"+ ret.append(list(map(int, read().split())))",
"+ return tuple(map(list, list(zip(*ret))))",
"+",
"+",
"+def read_matrix(H):",
"+ \"\"\"",
"+ H is number of rows",
"+ \"\"\"",
"+ ret = []",
"+ for _ in range(H):",
"+ ret.append(list(map(int, read().split())))",
"+ return ret",
"+ # return [list(map(int, read().split())) for _ in range(H)] # 内包表記はpypyでは遅いため",
"+",
"+",
"+MOD = 10**9 + 7",
"+INF = 2**31 # 2147483648 > 10**9",
"+# default import",
"+from collections import defaultdict, Counter, deque",
"+from operator import itemgetter",
"+from itertools import product, permutations, combinations",
"+from bisect import bisect_left, bisect_right # , insort_left, insort_right",
"+",
"-N, K = list(map(int, input().split()))",
"-probs = []",
"-keisuu = 1 / N",
"-for dice in range(1, N + 1):",
"- score = dice",
"- cnt = 0",
"- while score < K:",
"- score *= 2",
"- cnt += 1",
"- probs.append(keisuu * (1 / 2) ** cnt)",
"-print((sum(probs)))",
"+# 最初のサイコロでコインを最大何回降るか決まる",
"+# 最大表が出続ける確率がすぬけくんの勝つ確率",
"+# はじめにサイコロの確率も考慮したい",
"+N, K = read_ints()",
"+mul = 1 / N",
"+ans = 0",
"+for i in ra(1, N + 1):",
"+ n_coin = 0",
"+ prob_win = 1",
"+ while i < K:",
"+ i *= 2",
"+ prob_win /= 2",
"+ ans += prob_win",
"+print((ans * mul))"
] | false | 0.195841 | 0.052066 | 3.761365 |
[
"s477547811",
"s047039783"
] |
u775421443
|
p03160
|
python
|
s001013931
|
s646649816
| 130 | 114 | 14,184 | 14,236 |
Accepted
|
Accepted
| 12.31 |
n = int(eval(input()))
h = tuple(map(int, input().split()))
c = [0] * n
c[0] = 0
c[1] = abs(h[0] - h[1])
for i in range(2, n):
c[i] = min(c[i - 1] + abs(h[i - 1] - h[i]), c[i - 2] + abs(h[i - 2] - h[i]))
print((c[-1]))
|
n = int(eval(input()))
hs = tuple(map(int, input().split()))
a, b = 0, abs(hs[1] - hs[0])
for i in range(2, n):
c = hs[i]
a, b = b, min(a + abs(c - hs[i-2]), b + abs(c - hs[i-1]))
print(b)
| 11 | 10 | 228 | 199 |
n = int(eval(input()))
h = tuple(map(int, input().split()))
c = [0] * n
c[0] = 0
c[1] = abs(h[0] - h[1])
for i in range(2, n):
c[i] = min(c[i - 1] + abs(h[i - 1] - h[i]), c[i - 2] + abs(h[i - 2] - h[i]))
print((c[-1]))
|
n = int(eval(input()))
hs = tuple(map(int, input().split()))
a, b = 0, abs(hs[1] - hs[0])
for i in range(2, n):
c = hs[i]
a, b = b, min(a + abs(c - hs[i - 2]), b + abs(c - hs[i - 1]))
print(b)
| false | 9.090909 |
[
"-h = tuple(map(int, input().split()))",
"-c = [0] * n",
"-c[0] = 0",
"-c[1] = abs(h[0] - h[1])",
"+hs = tuple(map(int, input().split()))",
"+a, b = 0, abs(hs[1] - hs[0])",
"- c[i] = min(c[i - 1] + abs(h[i - 1] - h[i]), c[i - 2] + abs(h[i - 2] - h[i]))",
"-print((c[-1]))",
"+ c = hs[i]",
"+ a, b = b, min(a + abs(c - hs[i - 2]), b + abs(c - hs[i - 1]))",
"+print(b)"
] | false | 0.03961 | 0.037641 | 1.052332 |
[
"s001013931",
"s646649816"
] |
u852690916
|
p02696
|
python
|
s313853433
|
s304172061
| 60 | 22 | 61,788 | 9,124 |
Accepted
|
Accepted
| 63.33 |
A,B,N=list(map(int, input().split()))
print((A*min(B-1,N)//B))
|
A, B, N = list(map(int, input().split()))
m = B - 1 if N >= B else N
print((A * m // B))
| 2 | 3 | 55 | 83 |
A, B, N = list(map(int, input().split()))
print((A * min(B - 1, N) // B))
|
A, B, N = list(map(int, input().split()))
m = B - 1 if N >= B else N
print((A * m // B))
| false | 33.333333 |
[
"-print((A * min(B - 1, N) // B))",
"+m = B - 1 if N >= B else N",
"+print((A * m // B))"
] | false | 0.007224 | 0.041521 | 0.173975 |
[
"s313853433",
"s304172061"
] |
u983918956
|
p03231
|
python
|
s106238880
|
s783810241
| 408 | 58 | 66,792 | 5,860 |
Accepted
|
Accepted
| 85.78 |
import fractions
import sys
input = sys.stdin.readline
N,M = list(map(int,input().split()))
S = eval(input()); T = eval(input())
gcd = fractions.gcd(N,M)
N_prime = N //gcd; M_prime = M // gcd
for i in range(0,N,N_prime):
for j in range(0,M,M_prime):
if i * M_prime - j * N_prime == 0 and S[i] != T[j]:
print((-1))
exit()
print((N*M // gcd))
|
from fractions import gcd
def lcm_base(x,y):
return (x*y) // gcd(x,y)
N,M = list(map(int,input().split()))
S = eval(input())
T = eval(input())
ans = lcm_base(N,M)
for i in range(N):
if M*i % N != 0:
continue
j = M*i // N
if j >= M:
continue
if S[i] != T[j]:
print((-1))
exit()
print(ans)
| 13 | 18 | 366 | 337 |
import fractions
import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
S = eval(input())
T = eval(input())
gcd = fractions.gcd(N, M)
N_prime = N // gcd
M_prime = M // gcd
for i in range(0, N, N_prime):
for j in range(0, M, M_prime):
if i * M_prime - j * N_prime == 0 and S[i] != T[j]:
print((-1))
exit()
print((N * M // gcd))
|
from fractions import gcd
def lcm_base(x, y):
return (x * y) // gcd(x, y)
N, M = list(map(int, input().split()))
S = eval(input())
T = eval(input())
ans = lcm_base(N, M)
for i in range(N):
if M * i % N != 0:
continue
j = M * i // N
if j >= M:
continue
if S[i] != T[j]:
print((-1))
exit()
print(ans)
| false | 27.777778 |
[
"-import fractions",
"-import sys",
"+from fractions import gcd",
"-input = sys.stdin.readline",
"+",
"+def lcm_base(x, y):",
"+ return (x * y) // gcd(x, y)",
"+",
"+",
"-gcd = fractions.gcd(N, M)",
"-N_prime = N // gcd",
"-M_prime = M // gcd",
"-for i in range(0, N, N_prime):",
"- for j in range(0, M, M_prime):",
"- if i * M_prime - j * N_prime == 0 and S[i] != T[j]:",
"- print((-1))",
"- exit()",
"-print((N * M // gcd))",
"+ans = lcm_base(N, M)",
"+for i in range(N):",
"+ if M * i % N != 0:",
"+ continue",
"+ j = M * i // N",
"+ if j >= M:",
"+ continue",
"+ if S[i] != T[j]:",
"+ print((-1))",
"+ exit()",
"+print(ans)"
] | false | 0.0404 | 0.068522 | 0.58959 |
[
"s106238880",
"s783810241"
] |
u571281863
|
p02678
|
python
|
s847829581
|
s487341501
| 409 | 355 | 56,668 | 56,520 |
Accepted
|
Accepted
| 13.2 |
from collections import deque
N,M,*AB=map(int,open(0).read().split())
to=[[] for _ in range(N)]
for a,b in zip(*[iter(AB)]*2):
to[a-1].append(b-1)
to[b-1].append(a-1)
q=deque([0])
r=[None]*N
while q:
x=q.popleft()
for i in to[x]:
if r[i] is None:
q.append(i)
r[i]=x+1
print("Yes",*r[1:],sep="\n")
|
from collections import deque
def main():
N,M,*AB=map(int,open(0).read().split())
to=[[] for _ in range(N)]
for a,b in zip(*[iter(AB)]*2):
to[a-1].append(b-1)
to[b-1].append(a-1)
q=deque([0])
r=[None]*N
while q:
x=q.popleft()
for i in to[x]:
if r[i] is None:
q.append(i)
r[i]=x+1
print("Yes",*r[1:],sep="\n")
if __name__=='__main__':
main()
| 15 | 18 | 334 | 384 |
from collections import deque
N, M, *AB = map(int, open(0).read().split())
to = [[] for _ in range(N)]
for a, b in zip(*[iter(AB)] * 2):
to[a - 1].append(b - 1)
to[b - 1].append(a - 1)
q = deque([0])
r = [None] * N
while q:
x = q.popleft()
for i in to[x]:
if r[i] is None:
q.append(i)
r[i] = x + 1
print("Yes", *r[1:], sep="\n")
|
from collections import deque
def main():
N, M, *AB = map(int, open(0).read().split())
to = [[] for _ in range(N)]
for a, b in zip(*[iter(AB)] * 2):
to[a - 1].append(b - 1)
to[b - 1].append(a - 1)
q = deque([0])
r = [None] * N
while q:
x = q.popleft()
for i in to[x]:
if r[i] is None:
q.append(i)
r[i] = x + 1
print("Yes", *r[1:], sep="\n")
if __name__ == "__main__":
main()
| false | 16.666667 |
[
"-N, M, *AB = map(int, open(0).read().split())",
"-to = [[] for _ in range(N)]",
"-for a, b in zip(*[iter(AB)] * 2):",
"- to[a - 1].append(b - 1)",
"- to[b - 1].append(a - 1)",
"-q = deque([0])",
"-r = [None] * N",
"-while q:",
"- x = q.popleft()",
"- for i in to[x]:",
"- if r[i] is None:",
"- q.append(i)",
"- r[i] = x + 1",
"-print(\"Yes\", *r[1:], sep=\"\\n\")",
"+",
"+def main():",
"+ N, M, *AB = map(int, open(0).read().split())",
"+ to = [[] for _ in range(N)]",
"+ for a, b in zip(*[iter(AB)] * 2):",
"+ to[a - 1].append(b - 1)",
"+ to[b - 1].append(a - 1)",
"+ q = deque([0])",
"+ r = [None] * N",
"+ while q:",
"+ x = q.popleft()",
"+ for i in to[x]:",
"+ if r[i] is None:",
"+ q.append(i)",
"+ r[i] = x + 1",
"+ print(\"Yes\", *r[1:], sep=\"\\n\")",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false | 0.036308 | 0.040522 | 0.896015 |
[
"s847829581",
"s487341501"
] |
u753803401
|
p03087
|
python
|
s005277799
|
s446781511
| 852 | 373 | 9,204 | 64,476 |
Accepted
|
Accepted
| 56.22 |
n, q = list(map(int, input().split()))
s = eval(input())
a = [0] * n
t = 0
for i in range(1, n):
if s[i-1] == "A" and s[i] == "C":
t += 1
a[i] += t
for i in range(q):
l, r = list(map(int, input().split()))
print((a[r-1] - a[l-1]))
|
def main():
import sys
input = sys.stdin.readline
n, q = list(map(int, input().rstrip('\n').split()))
s = str(input().rstrip('\n'))
ss = [0] * n
t = 0
for i in range(n):
if s[i] == "C" and s[i-1] == "A":
t += 1
ss[i] = t
for l, r in [list(map(int, input().split())) for _ in range(q)]:
print((ss[r-1] - ss[l-1]))
if __name__ == '__main__':
main()
| 11 | 17 | 245 | 435 |
n, q = list(map(int, input().split()))
s = eval(input())
a = [0] * n
t = 0
for i in range(1, n):
if s[i - 1] == "A" and s[i] == "C":
t += 1
a[i] += t
for i in range(q):
l, r = list(map(int, input().split()))
print((a[r - 1] - a[l - 1]))
|
def main():
import sys
input = sys.stdin.readline
n, q = list(map(int, input().rstrip("\n").split()))
s = str(input().rstrip("\n"))
ss = [0] * n
t = 0
for i in range(n):
if s[i] == "C" and s[i - 1] == "A":
t += 1
ss[i] = t
for l, r in [list(map(int, input().split())) for _ in range(q)]:
print((ss[r - 1] - ss[l - 1]))
if __name__ == "__main__":
main()
| false | 35.294118 |
[
"-n, q = list(map(int, input().split()))",
"-s = eval(input())",
"-a = [0] * n",
"-t = 0",
"-for i in range(1, n):",
"- if s[i - 1] == \"A\" and s[i] == \"C\":",
"- t += 1",
"- a[i] += t",
"-for i in range(q):",
"- l, r = list(map(int, input().split()))",
"- print((a[r - 1] - a[l - 1]))",
"+def main():",
"+ import sys",
"+",
"+ input = sys.stdin.readline",
"+ n, q = list(map(int, input().rstrip(\"\\n\").split()))",
"+ s = str(input().rstrip(\"\\n\"))",
"+ ss = [0] * n",
"+ t = 0",
"+ for i in range(n):",
"+ if s[i] == \"C\" and s[i - 1] == \"A\":",
"+ t += 1",
"+ ss[i] = t",
"+ for l, r in [list(map(int, input().split())) for _ in range(q)]:",
"+ print((ss[r - 1] - ss[l - 1]))",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false | 0.111767 | 0.042692 | 2.617949 |
[
"s005277799",
"s446781511"
] |
u340781749
|
p03425
|
python
|
s795257460
|
s269363981
| 273 | 161 | 3,564 | 3,316 |
Accepted
|
Accepted
| 41.03 |
from collections import defaultdict
from itertools import combinations
n = int(eval(input()))
d = defaultdict(int)
for _ in range(n):
s = eval(input())
d[s[0]] += 1
con = []
for c in ('M', 'A', 'R', 'C', 'H'):
k = d[c]
if k:
con.append(k)
ans = 0
for a, b, c in combinations(con, 3):
ans += a * b * c
print(ans)
|
from collections import Counter
from itertools import combinations
n = int(eval(input()))
l = Counter(input()[0] for _ in range(n))
con = [l[c] for c in 'MARCH' if c in l]
print((sum(a * b * c for a, b, c in combinations(con, 3))))
| 20 | 7 | 351 | 231 |
from collections import defaultdict
from itertools import combinations
n = int(eval(input()))
d = defaultdict(int)
for _ in range(n):
s = eval(input())
d[s[0]] += 1
con = []
for c in ("M", "A", "R", "C", "H"):
k = d[c]
if k:
con.append(k)
ans = 0
for a, b, c in combinations(con, 3):
ans += a * b * c
print(ans)
|
from collections import Counter
from itertools import combinations
n = int(eval(input()))
l = Counter(input()[0] for _ in range(n))
con = [l[c] for c in "MARCH" if c in l]
print((sum(a * b * c for a, b, c in combinations(con, 3))))
| false | 65 |
[
"-from collections import defaultdict",
"+from collections import Counter",
"-d = defaultdict(int)",
"-for _ in range(n):",
"- s = eval(input())",
"- d[s[0]] += 1",
"-con = []",
"-for c in (\"M\", \"A\", \"R\", \"C\", \"H\"):",
"- k = d[c]",
"- if k:",
"- con.append(k)",
"-ans = 0",
"-for a, b, c in combinations(con, 3):",
"- ans += a * b * c",
"-print(ans)",
"+l = Counter(input()[0] for _ in range(n))",
"+con = [l[c] for c in \"MARCH\" if c in l]",
"+print((sum(a * b * c for a, b, c in combinations(con, 3))))"
] | false | 0.068737 | 0.054821 | 1.253861 |
[
"s795257460",
"s269363981"
] |
u766393261
|
p02983
|
python
|
s571699277
|
s589036728
| 635 | 67 | 75,332 | 6,892 |
Accepted
|
Accepted
| 89.45 |
L,R=list(map(int,input().split()))
ans=[]
if (R-L)>2019:
print((0))
else:
for m in range(L,R+1):
for j in range(m+1,R+1):
ans.append(m*j%2019)
print((min(ans)))
|
import sys
L,R=list(map(int,input().split()))
ans=[]
if (R-L)>2019:
print((0))
else:
for m in range(L,R+1):
for j in range(m+1,R+1):
ans.append(m*j%2019)
if m*j%2019==0:
print((0))
sys.exit()
print((min(ans)))
| 11 | 13 | 219 | 281 |
L, R = list(map(int, input().split()))
ans = []
if (R - L) > 2019:
print((0))
else:
for m in range(L, R + 1):
for j in range(m + 1, R + 1):
ans.append(m * j % 2019)
print((min(ans)))
|
import sys
L, R = list(map(int, input().split()))
ans = []
if (R - L) > 2019:
print((0))
else:
for m in range(L, R + 1):
for j in range(m + 1, R + 1):
ans.append(m * j % 2019)
if m * j % 2019 == 0:
print((0))
sys.exit()
print((min(ans)))
| false | 15.384615 |
[
"+import sys",
"+",
"+ if m * j % 2019 == 0:",
"+ print((0))",
"+ sys.exit()"
] | false | 0.054762 | 0.047399 | 1.15535 |
[
"s571699277",
"s589036728"
] |
u729133443
|
p02762
|
python
|
s368850382
|
s624729947
| 1,847 | 1,503 | 96,856 | 96,856 |
Accepted
|
Accepted
| 18.62 |
r=lambda x:p[x]>=0and r(p[x])or x
(n,m,k),*t=[list(map(int,t.split()))for t in open(0)]
p,s=[-1]*-~n,[-1]*-~n
for i,(a,b)in enumerate(t):
x,y=r(a),r(b)
if(x!=y)*m>i:
if x>y:x,y=y,x
p[x]+=p[y]
p[y]=x
if r(a)==r(b)or i<m:
s[a]-=1
s[b]-=1
for i in range(n+1):s[i]-=p[r(i)]
print((*s[1:]))
|
r=lambda x:p[x]>=0and r(p[x])or x
(n,m,k),*t=[list(map(int,t.split()))for t in open(0)]
p,s=[-1]*-~n,[-1]*-~n
for i,(a,b)in enumerate(t):
x,y=r(a),r(b)
if(x!=y)*m>i:
if x>y:x,y=y,x
p[x]+=p[y]
p[y]=x
if x==y or i<m:
s[a]-=1
s[b]-=1
for i in range(n+1):s[i]-=p[r(i)]
print((*s[1:]))
| 14 | 14 | 316 | 311 |
r = lambda x: p[x] >= 0 and r(p[x]) or x
(n, m, k), *t = [list(map(int, t.split())) for t in open(0)]
p, s = [-1] * -~n, [-1] * -~n
for i, (a, b) in enumerate(t):
x, y = r(a), r(b)
if (x != y) * m > i:
if x > y:
x, y = y, x
p[x] += p[y]
p[y] = x
if r(a) == r(b) or i < m:
s[a] -= 1
s[b] -= 1
for i in range(n + 1):
s[i] -= p[r(i)]
print((*s[1:]))
|
r = lambda x: p[x] >= 0 and r(p[x]) or x
(n, m, k), *t = [list(map(int, t.split())) for t in open(0)]
p, s = [-1] * -~n, [-1] * -~n
for i, (a, b) in enumerate(t):
x, y = r(a), r(b)
if (x != y) * m > i:
if x > y:
x, y = y, x
p[x] += p[y]
p[y] = x
if x == y or i < m:
s[a] -= 1
s[b] -= 1
for i in range(n + 1):
s[i] -= p[r(i)]
print((*s[1:]))
| false | 0 |
[
"- if r(a) == r(b) or i < m:",
"+ if x == y or i < m:"
] | false | 0.048304 | 0.048571 | 0.994503 |
[
"s368850382",
"s624729947"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.