user_id
stringlengths 10
10
| problem_id
stringlengths 6
6
| language
stringclasses 1
value | submission_id_v0
stringlengths 10
10
| submission_id_v1
stringlengths 10
10
| cpu_time_v0
int64 10
38.3k
| cpu_time_v1
int64 0
24.7k
| memory_v0
int64 2.57k
1.02M
| memory_v1
int64 2.57k
869k
| status_v0
stringclasses 1
value | status_v1
stringclasses 1
value | improvement_frac
float64 7.51
100
| input
stringlengths 20
4.55k
| target
stringlengths 17
3.34k
| code_v0_loc
int64 1
148
| code_v1_loc
int64 1
184
| code_v0_num_chars
int64 13
4.55k
| code_v1_num_chars
int64 14
3.34k
| code_v0_no_empty_lines
stringlengths 21
6.88k
| code_v1_no_empty_lines
stringlengths 20
4.93k
| code_same
bool 1
class | relative_loc_diff_percent
float64 0
79.8
| diff
sequence | diff_only_import_comment
bool 1
class | measured_runtime_v0
float64 0.01
4.45
| measured_runtime_v1
float64 0.01
4.31
| runtime_lift
float64 0
359
| key
sequence |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
u731368968 | p03846 | python | s052059355 | s349703918 | 74 | 66 | 14,008 | 14,008 | Accepted | Accepted | 10.81 | n = int(eval(input()))
a = list(map(int, input().split()))
l=[0 for i in range(n)]
for x in a:
l[x] += 1
p = [(0 if i % 2 == 0 else 2) for i in range(n // 2 * 2)]
if n % 2 == 1: p = [1] + p
if l != p:
print((0))
import sys
sys.exit()
def mod_power(x, a, p):
if a == 0:
return 1
t = mod_power(x, a // 2, p)
if a % 2 == 0:
return t * t
else:
return x * t % p * t
ans = 1
for i in range(n // 2):
ans *= 2
ans %= 10 ** 9 + 7
print(ans)
# print(mod_power(2,n//2,10**9+7))
| n = int(eval(input()))
a = list(map(int, input().split()))
l=[0 for i in range(n)]
for x in a:
l[x] += 1
p = [(0 if i % 2 == 0 else 2) for i in range(n // 2 * 2)]
if n % 2 == 1: p = [1] + p
if l != p:
print((0))
import sys
sys.exit()
def mod_power(x, a, p):
if a == 0:
return 1
t = mod_power(x, a // 2, p)
if a % 2 == 0:
return t * t % p
else:
return x * t * t % p
ans = 1
# for i in range(n // 2):
# ans *= 2
# ans %= 10 ** 9 + 7
# print(ans)
print((mod_power(2,n//2,10**9+7)))
| 28 | 28 | 553 | 563 | n = int(eval(input()))
a = list(map(int, input().split()))
l = [0 for i in range(n)]
for x in a:
l[x] += 1
p = [(0 if i % 2 == 0 else 2) for i in range(n // 2 * 2)]
if n % 2 == 1:
p = [1] + p
if l != p:
print((0))
import sys
sys.exit()
def mod_power(x, a, p):
if a == 0:
return 1
t = mod_power(x, a // 2, p)
if a % 2 == 0:
return t * t
else:
return x * t % p * t
ans = 1
for i in range(n // 2):
ans *= 2
ans %= 10**9 + 7
print(ans)
# print(mod_power(2,n//2,10**9+7))
| n = int(eval(input()))
a = list(map(int, input().split()))
l = [0 for i in range(n)]
for x in a:
l[x] += 1
p = [(0 if i % 2 == 0 else 2) for i in range(n // 2 * 2)]
if n % 2 == 1:
p = [1] + p
if l != p:
print((0))
import sys
sys.exit()
def mod_power(x, a, p):
if a == 0:
return 1
t = mod_power(x, a // 2, p)
if a % 2 == 0:
return t * t % p
else:
return x * t * t % p
ans = 1
# for i in range(n // 2):
# ans *= 2
# ans %= 10 ** 9 + 7
# print(ans)
print((mod_power(2, n // 2, 10**9 + 7)))
| false | 0 | [
"- return t * t",
"+ return t * t % p",
"- return x * t % p * t",
"+ return x * t * t % p",
"-for i in range(n // 2):",
"- ans *= 2",
"- ans %= 10**9 + 7",
"-print(ans)",
"-# print(mod_power(2,n//2,10**9+7))",
"+# for i in range(n // 2):",
"+# ans *= 2",
"+# ans %= 10 ** 9 + 7",
"+# print(ans)",
"+print((mod_power(2, n // 2, 10**9 + 7)))"
] | false | 0.04575 | 0.034835 | 1.313344 | [
"s052059355",
"s349703918"
] |
u241159583 | p03937 | python | s709527422 | s579696163 | 20 | 17 | 3,060 | 2,940 | Accepted | Accepted | 15 | H, W = list(map(int, input().split()))
A = [list(eval(input())) for _ in range(H)]
cnt = 0
for i in range(H):
cnt += A[i].count("#")
print(("Possible" if cnt == H + W - 1 else "Impossible")) | H,W = list(map(int, input().split()))
A = [eval(input()) for _ in range(H)]
cnt = 0
for a in A:
cnt += a.count("#")
print(("Possible" if cnt == W + (H-1) else "Impossible")) | 7 | 7 | 185 | 170 | H, W = list(map(int, input().split()))
A = [list(eval(input())) for _ in range(H)]
cnt = 0
for i in range(H):
cnt += A[i].count("#")
print(("Possible" if cnt == H + W - 1 else "Impossible"))
| H, W = list(map(int, input().split()))
A = [eval(input()) for _ in range(H)]
cnt = 0
for a in A:
cnt += a.count("#")
print(("Possible" if cnt == W + (H - 1) else "Impossible"))
| false | 0 | [
"-A = [list(eval(input())) for _ in range(H)]",
"+A = [eval(input()) for _ in range(H)]",
"-for i in range(H):",
"- cnt += A[i].count(\"#\")",
"-print((\"Possible\" if cnt == H + W - 1 else \"Impossible\"))",
"+for a in A:",
"+ cnt += a.count(\"#\")",
"+print((\"Possible\" if cnt == W + (H - 1) else \"Impossible\"))"
] | false | 0.034503 | 0.048184 | 0.716083 | [
"s709527422",
"s579696163"
] |
u541055501 | p02586 | python | s942681998 | s496711970 | 1,884 | 1,734 | 428,600 | 428,412 | Accepted | Accepted | 7.96 | f,g,h=range,max,input
R,C,K=list(map(int,h().split()))
G=[[0]*-~C for i in f(R+1)]
for i in'_'*K:r,c,v=list(map(int,h().split()));G[r][c]=v
F=[[[0]*-~C for i in f(R+1)]for i in f(4)]
for r in f(1,R+1):
for x in f(1,4):
for c in f(1,C+1):F[x][r][c]=g(F[x-1][r][c],F[x-1][r][c-1]+G[r][c],F[x][r][c-1],(x<2)*(G[r][c]+F[3][r-1][c]))
print((F[3][R][C])) | f,h=range,input
R,C,K=list(map(int,h().split()))
G=[[0]*-~C for i in f(R+1)]
for i in'_'*K:r,c,v=list(map(int,h().split()));G[r][c]=v
F=[[[0]*-~C for i in f(R+1)]for i in f(4)]
for r in f(1,R+1):
for x in f(1,4):
for c in f(1,C+1):F[x][r][c]=max(F[x-1][r][c],max(F[x-1][r][c-1],(x<2)*F[3][r-1][c])+G[r][c],F[x][r][c-1])
print((F[3][R][C])) | 9 | 9 | 345 | 336 | f, g, h = range, max, input
R, C, K = list(map(int, h().split()))
G = [[0] * -~C for i in f(R + 1)]
for i in "_" * K:
r, c, v = list(map(int, h().split()))
G[r][c] = v
F = [[[0] * -~C for i in f(R + 1)] for i in f(4)]
for r in f(1, R + 1):
for x in f(1, 4):
for c in f(1, C + 1):
F[x][r][c] = g(
F[x - 1][r][c],
F[x - 1][r][c - 1] + G[r][c],
F[x][r][c - 1],
(x < 2) * (G[r][c] + F[3][r - 1][c]),
)
print((F[3][R][C]))
| f, h = range, input
R, C, K = list(map(int, h().split()))
G = [[0] * -~C for i in f(R + 1)]
for i in "_" * K:
r, c, v = list(map(int, h().split()))
G[r][c] = v
F = [[[0] * -~C for i in f(R + 1)] for i in f(4)]
for r in f(1, R + 1):
for x in f(1, 4):
for c in f(1, C + 1):
F[x][r][c] = max(
F[x - 1][r][c],
max(F[x - 1][r][c - 1], (x < 2) * F[3][r - 1][c]) + G[r][c],
F[x][r][c - 1],
)
print((F[3][R][C]))
| false | 0 | [
"-f, g, h = range, max, input",
"+f, h = range, input",
"- F[x][r][c] = g(",
"+ F[x][r][c] = max(",
"- F[x - 1][r][c - 1] + G[r][c],",
"+ max(F[x - 1][r][c - 1], (x < 2) * F[3][r - 1][c]) + G[r][c],",
"- (x < 2) * (G[r][c] + F[3][r - 1][c]),"
] | false | 0.042796 | 0.04963 | 0.862312 | [
"s942681998",
"s496711970"
] |
u724687935 | p02850 | python | s728712765 | s500713057 | 674 | 526 | 40,128 | 75,112 | Accepted | Accepted | 21.96 | from collections import deque
N = int(eval(input()))
edge = [[] for _ in range(N)]
for i in range(N - 1):
a, b = list(map(int, input().split()))
edge[a - 1].append((b - 1, i))
edge[b - 1].append((a - 1, i))
ec = [0] * (N - 1)
def bfs():
q = deque()
q.append((0, 0))
while len(q):
v, pc = q.popleft()
color = 1
for e in edge[v]:
if color == pc:
color += 1
if ec[e[1]] == 0:
ec[e[1]] = color
q.append((e[0], color))
color += 1
bfs()
print((max(ec)))
for c in ec:
print(c)
| import sys
sys.setrecursionlimit(10 ** 6)
def dfs(v, c):
nc = 0
k = 0
for nv, idx in edge[v]:
if status[nv] == 0:
nc = nc + 1 + ((nc + 1) == c)
color[idx] = nc
status[nv] = 1
k = max(k, dfs(nv, nc))
return max(nc, k)
N = int(eval(input()))
edge = [[] for _ in range(N)]
for idx, line in enumerate(sys.stdin.readlines()):
a, b = [int(x) - 1 for x in line.split()]
edge[a].append((b, idx))
edge[b].append((a, idx))
status = [0] * N
color = [0] * (N - 1)
status[0] = 1
K = dfs(0, 0)
print(K)
for c in color:
print(c)
| 33 | 31 | 636 | 637 | from collections import deque
N = int(eval(input()))
edge = [[] for _ in range(N)]
for i in range(N - 1):
a, b = list(map(int, input().split()))
edge[a - 1].append((b - 1, i))
edge[b - 1].append((a - 1, i))
ec = [0] * (N - 1)
def bfs():
q = deque()
q.append((0, 0))
while len(q):
v, pc = q.popleft()
color = 1
for e in edge[v]:
if color == pc:
color += 1
if ec[e[1]] == 0:
ec[e[1]] = color
q.append((e[0], color))
color += 1
bfs()
print((max(ec)))
for c in ec:
print(c)
| import sys
sys.setrecursionlimit(10**6)
def dfs(v, c):
nc = 0
k = 0
for nv, idx in edge[v]:
if status[nv] == 0:
nc = nc + 1 + ((nc + 1) == c)
color[idx] = nc
status[nv] = 1
k = max(k, dfs(nv, nc))
return max(nc, k)
N = int(eval(input()))
edge = [[] for _ in range(N)]
for idx, line in enumerate(sys.stdin.readlines()):
a, b = [int(x) - 1 for x in line.split()]
edge[a].append((b, idx))
edge[b].append((a, idx))
status = [0] * N
color = [0] * (N - 1)
status[0] = 1
K = dfs(0, 0)
print(K)
for c in color:
print(c)
| false | 6.060606 | [
"-from collections import deque",
"+import sys",
"+",
"+sys.setrecursionlimit(10**6)",
"+",
"+",
"+def dfs(v, c):",
"+ nc = 0",
"+ k = 0",
"+ for nv, idx in edge[v]:",
"+ if status[nv] == 0:",
"+ nc = nc + 1 + ((nc + 1) == c)",
"+ color[idx] = nc",
"+ status[nv] = 1",
"+ k = max(k, dfs(nv, nc))",
"+ return max(nc, k)",
"+",
"-for i in range(N - 1):",
"- a, b = list(map(int, input().split()))",
"- edge[a - 1].append((b - 1, i))",
"- edge[b - 1].append((a - 1, i))",
"-ec = [0] * (N - 1)",
"-",
"-",
"-def bfs():",
"- q = deque()",
"- q.append((0, 0))",
"- while len(q):",
"- v, pc = q.popleft()",
"- color = 1",
"- for e in edge[v]:",
"- if color == pc:",
"- color += 1",
"- if ec[e[1]] == 0:",
"- ec[e[1]] = color",
"- q.append((e[0], color))",
"- color += 1",
"-",
"-",
"-bfs()",
"-print((max(ec)))",
"-for c in ec:",
"+for idx, line in enumerate(sys.stdin.readlines()):",
"+ a, b = [int(x) - 1 for x in line.split()]",
"+ edge[a].append((b, idx))",
"+ edge[b].append((a, idx))",
"+status = [0] * N",
"+color = [0] * (N - 1)",
"+status[0] = 1",
"+K = dfs(0, 0)",
"+print(K)",
"+for c in color:"
] | false | 0.105563 | 0.064177 | 1.64487 | [
"s728712765",
"s500713057"
] |
u645250356 | p03644 | python | s889022944 | s378803489 | 173 | 36 | 38,384 | 5,076 | Accepted | Accepted | 79.19 | from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
import sys,bisect,math,itertools
sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpln(n): return list(int(sys.stdin.readline()) for i in range(n))
n = inp()
res = 0
cc = 0
for i in range(1,n+1):
tmp = i
cnt = 0
while True:
if tmp%2==0:
tmp //= 2
cnt += 1
else:
break
if cnt >= cc:
cc = cnt
res = i
print(res) | from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
import sys,bisect,math,itertools,fractions
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
n = inp()
now = 1
while True:
if now*2 > n:
print(now)
break
now *= 2
| 25 | 17 | 624 | 418 | from collections import Counter, defaultdict, deque
from heapq import heappop, heappush, heapify
import sys, bisect, math, itertools
sys.setrecursionlimit(10**8)
mod = 10**9 + 7
def inp():
return int(sys.stdin.readline())
def inpl():
return list(map(int, sys.stdin.readline().split()))
def inpln(n):
return list(int(sys.stdin.readline()) for i in range(n))
n = inp()
res = 0
cc = 0
for i in range(1, n + 1):
tmp = i
cnt = 0
while True:
if tmp % 2 == 0:
tmp //= 2
cnt += 1
else:
break
if cnt >= cc:
cc = cnt
res = i
print(res)
| from collections import Counter, defaultdict, deque
from heapq import heappop, heappush, heapify
import sys, bisect, math, itertools, fractions
sys.setrecursionlimit(10**8)
mod = 10**9 + 7
INF = float("inf")
def inp():
return int(sys.stdin.readline())
def inpl():
return list(map(int, sys.stdin.readline().split()))
n = inp()
now = 1
while True:
if now * 2 > n:
print(now)
break
now *= 2
| false | 32 | [
"-import sys, bisect, math, itertools",
"+import sys, bisect, math, itertools, fractions",
"+INF = float(\"inf\")",
"-def inpln(n):",
"- return list(int(sys.stdin.readline()) for i in range(n))",
"-",
"-",
"-res = 0",
"-cc = 0",
"-for i in range(1, n + 1):",
"- tmp = i",
"- cnt = 0",
"- while True:",
"- if tmp % 2 == 0:",
"- tmp //= 2",
"- cnt += 1",
"- else:",
"- break",
"- if cnt >= cc:",
"- cc = cnt",
"- res = i",
"-print(res)",
"+now = 1",
"+while True:",
"+ if now * 2 > n:",
"+ print(now)",
"+ break",
"+ now *= 2"
] | false | 0.04477 | 0.03769 | 1.187849 | [
"s889022944",
"s378803489"
] |
u123756661 | p03038 | python | s689476413 | s026740259 | 1,274 | 642 | 101,400 | 20,724 | Accepted | Accepted | 49.61 | import heapq
def sol():
n,m=list(map(int,input().split()))
a=[int(i) for i in input().split()]
d={}
w=[]
q=[]
for i in a:
if i in d:
d[i]+=1
else:
d[i]=1
w.append(i)
for i in w: heapq.heappush(q, i)
for i in range(m):
b,c=list(map(int,input().split()))
while b:
if c>q[0]:
x=min(b,d[q[0]])
if c in d:
d[c]+=x
b-=x
d[q[0]]-=x
if d[q[0]]==0:
heapq.heappop(q)
else:
d[c]=x
b-=x
d[q[0]]-=x
heapq.heappush(q,c)
if d[q[0]]==0:
heapq.heappop(q)
else:
break
ans=chk=0
for i in d:
ans+=i*d[i]
print(ans)
if __name__=="__main__":
sol() | import heapq
n,m=list(map(int,input().split()))
a=[int(i) for i in input().split()]
d={}
w=[]
q=[]
for i in a:
if i in d:
d[i]+=1
else:
d[i]=1
w.append(i)
for i in w: heapq.heappush(q, i)
for i in range(m):
b,c=list(map(int,input().split()))
while b:
if c>q[0]:
x=min(b,d[q[0]])
if c in d:
d[c]+=x
b-=x
d[q[0]]-=x
if d[q[0]]==0:
heapq.heappop(q)
else:
d[c]=x
b-=x
d[q[0]]-=x
heapq.heappush(q,c)
if d[q[0]]==0:
heapq.heappop(q)
else:
break
ans=chk=0
for i in d:
ans+=i*d[i]
print(ans) | 41 | 37 | 994 | 799 | import heapq
def sol():
n, m = list(map(int, input().split()))
a = [int(i) for i in input().split()]
d = {}
w = []
q = []
for i in a:
if i in d:
d[i] += 1
else:
d[i] = 1
w.append(i)
for i in w:
heapq.heappush(q, i)
for i in range(m):
b, c = list(map(int, input().split()))
while b:
if c > q[0]:
x = min(b, d[q[0]])
if c in d:
d[c] += x
b -= x
d[q[0]] -= x
if d[q[0]] == 0:
heapq.heappop(q)
else:
d[c] = x
b -= x
d[q[0]] -= x
heapq.heappush(q, c)
if d[q[0]] == 0:
heapq.heappop(q)
else:
break
ans = chk = 0
for i in d:
ans += i * d[i]
print(ans)
if __name__ == "__main__":
sol()
| import heapq
n, m = list(map(int, input().split()))
a = [int(i) for i in input().split()]
d = {}
w = []
q = []
for i in a:
if i in d:
d[i] += 1
else:
d[i] = 1
w.append(i)
for i in w:
heapq.heappush(q, i)
for i in range(m):
b, c = list(map(int, input().split()))
while b:
if c > q[0]:
x = min(b, d[q[0]])
if c in d:
d[c] += x
b -= x
d[q[0]] -= x
if d[q[0]] == 0:
heapq.heappop(q)
else:
d[c] = x
b -= x
d[q[0]] -= x
heapq.heappush(q, c)
if d[q[0]] == 0:
heapq.heappop(q)
else:
break
ans = chk = 0
for i in d:
ans += i * d[i]
print(ans)
| false | 9.756098 | [
"-",
"-def sol():",
"- n, m = list(map(int, input().split()))",
"- a = [int(i) for i in input().split()]",
"- d = {}",
"- w = []",
"- q = []",
"- for i in a:",
"- if i in d:",
"- d[i] += 1",
"+n, m = list(map(int, input().split()))",
"+a = [int(i) for i in input().split()]",
"+d = {}",
"+w = []",
"+q = []",
"+for i in a:",
"+ if i in d:",
"+ d[i] += 1",
"+ else:",
"+ d[i] = 1",
"+ w.append(i)",
"+for i in w:",
"+ heapq.heappush(q, i)",
"+for i in range(m):",
"+ b, c = list(map(int, input().split()))",
"+ while b:",
"+ if c > q[0]:",
"+ x = min(b, d[q[0]])",
"+ if c in d:",
"+ d[c] += x",
"+ b -= x",
"+ d[q[0]] -= x",
"+ if d[q[0]] == 0:",
"+ heapq.heappop(q)",
"+ else:",
"+ d[c] = x",
"+ b -= x",
"+ d[q[0]] -= x",
"+ heapq.heappush(q, c)",
"+ if d[q[0]] == 0:",
"+ heapq.heappop(q)",
"- d[i] = 1",
"- w.append(i)",
"- for i in w:",
"- heapq.heappush(q, i)",
"- for i in range(m):",
"- b, c = list(map(int, input().split()))",
"- while b:",
"- if c > q[0]:",
"- x = min(b, d[q[0]])",
"- if c in d:",
"- d[c] += x",
"- b -= x",
"- d[q[0]] -= x",
"- if d[q[0]] == 0:",
"- heapq.heappop(q)",
"- else:",
"- d[c] = x",
"- b -= x",
"- d[q[0]] -= x",
"- heapq.heappush(q, c)",
"- if d[q[0]] == 0:",
"- heapq.heappop(q)",
"- else:",
"- break",
"- ans = chk = 0",
"- for i in d:",
"- ans += i * d[i]",
"- print(ans)",
"-",
"-",
"-if __name__ == \"__main__\":",
"- sol()",
"+ break",
"+ans = chk = 0",
"+for i in d:",
"+ ans += i * d[i]",
"+print(ans)"
] | false | 0.037468 | 0.057343 | 0.653398 | [
"s689476413",
"s026740259"
] |
u708255304 | p02696 | python | s336975188 | s544568963 | 25 | 20 | 9,160 | 9,072 | Accepted | Accepted | 20 | import math
A, B, N = list(map(int, input().split()))
ans = math.floor(A*min(N, B-1)/B) - A*math.floor(min(N, B-1)/B)
print(ans)
| A, B, N = list(map(int, input().split()))
ans = int(A*(min(N, B-1)/B))-A*int(min(N, B-1)/B)
print(ans)
| 4 | 3 | 126 | 99 | import math
A, B, N = list(map(int, input().split()))
ans = math.floor(A * min(N, B - 1) / B) - A * math.floor(min(N, B - 1) / B)
print(ans)
| A, B, N = list(map(int, input().split()))
ans = int(A * (min(N, B - 1) / B)) - A * int(min(N, B - 1) / B)
print(ans)
| false | 25 | [
"-import math",
"-",
"-ans = math.floor(A * min(N, B - 1) / B) - A * math.floor(min(N, B - 1) / B)",
"+ans = int(A * (min(N, B - 1) / B)) - A * int(min(N, B - 1) / B)"
] | false | 0.046334 | 0.044585 | 1.039216 | [
"s336975188",
"s544568963"
] |
u706414019 | p02848 | python | s235201529 | s974745080 | 47 | 36 | 9,176 | 9,188 | Accepted | Accepted | 23.4 | N = int(input())
S = input()
alfa = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
lis = []
for s in S:
for i in range(26):
if s == alfa[i]:
lis.append((i+N)%26)
break
for i in range(len(S)):
print(alfa[lis[i]],end = '')
| N = int(input())
S = input()
for i in range(len(S)):
a = ord(S[i])+N
if a > ord('Z'):
a -= 26
print(chr(a),end ='')
| 11 | 7 | 253 | 142 | N = int(input())
S = input()
alfa = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
lis = []
for s in S:
for i in range(26):
if s == alfa[i]:
lis.append((i + N) % 26)
break
for i in range(len(S)):
print(alfa[lis[i]], end="")
| N = int(input())
S = input()
for i in range(len(S)):
a = ord(S[i]) + N
if a > ord("Z"):
a -= 26
print(chr(a), end="")
| false | 36.363636 | [
"-alfa = \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\"",
"-lis = []",
"-for s in S:",
"- for i in range(26):",
"- if s == alfa[i]:",
"- lis.append((i + N) % 26)",
"- break",
"- print(alfa[lis[i]], end=\"\")",
"+ a = ord(S[i]) + N",
"+ if a > ord(\"Z\"):",
"+ a -= 26",
"+ print(chr(a), end=\"\")"
] | false | 0.040948 | 0.039261 | 1.042976 | [
"s235201529",
"s974745080"
] |
u528470578 | p03163 | python | s367843011 | s545956390 | 570 | 471 | 217,844 | 172,868 | Accepted | Accepted | 17.37 | N, W = list(map(int, input().split()))
wv = [list(map(int, input().split())) for _ in range(N)]
# DP
dp = [[0 for _ in range(W+1)] for _ in range(N+1)]
for i in range(N):
for j in range(W+1):
if wv[i][0] <= j:
dp[i+1][j] = max(dp[i][j - wv[i][0]] + wv[i][1], dp[i][j])
else:
dp[i+1][j] = dp[i][j]
print((dp[N][W])) | # Knapsack 1
N, W = list(map(int, input().split()))
wv = [list(map(int, input().split())) for _ in range(N)]
dp = [[0 for i in range(W + 1)] for j in range(N + 1)]
for n in range(N):
for w in range(W + 1):
if wv[n][0] <= w:
dp[n+1][w] = max(dp[n][w], dp[n][w - wv[n][0]] + wv[n][1])
else:
dp[n+1][w] = dp[n][w]
print((dp[N][W])) | 12 | 11 | 362 | 374 | N, W = list(map(int, input().split()))
wv = [list(map(int, input().split())) for _ in range(N)]
# DP
dp = [[0 for _ in range(W + 1)] for _ in range(N + 1)]
for i in range(N):
for j in range(W + 1):
if wv[i][0] <= j:
dp[i + 1][j] = max(dp[i][j - wv[i][0]] + wv[i][1], dp[i][j])
else:
dp[i + 1][j] = dp[i][j]
print((dp[N][W]))
| # Knapsack 1
N, W = list(map(int, input().split()))
wv = [list(map(int, input().split())) for _ in range(N)]
dp = [[0 for i in range(W + 1)] for j in range(N + 1)]
for n in range(N):
for w in range(W + 1):
if wv[n][0] <= w:
dp[n + 1][w] = max(dp[n][w], dp[n][w - wv[n][0]] + wv[n][1])
else:
dp[n + 1][w] = dp[n][w]
print((dp[N][W]))
| false | 8.333333 | [
"+# Knapsack 1",
"-# DP",
"-dp = [[0 for _ in range(W + 1)] for _ in range(N + 1)]",
"-for i in range(N):",
"- for j in range(W + 1):",
"- if wv[i][0] <= j:",
"- dp[i + 1][j] = max(dp[i][j - wv[i][0]] + wv[i][1], dp[i][j])",
"+dp = [[0 for i in range(W + 1)] for j in range(N + 1)]",
"+for n in range(N):",
"+ for w in range(W + 1):",
"+ if wv[n][0] <= w:",
"+ dp[n + 1][w] = max(dp[n][w], dp[n][w - wv[n][0]] + wv[n][1])",
"- dp[i + 1][j] = dp[i][j]",
"+ dp[n + 1][w] = dp[n][w]"
] | false | 0.047452 | 0.046813 | 1.013645 | [
"s367843011",
"s545956390"
] |
u761989513 | p03262 | python | s221422158 | s093736633 | 111 | 90 | 14,596 | 14,748 | Accepted | Accepted | 18.92 | from functools import reduce
n, X = list(map(int, input().split()))
x = list(map(int, input().split()))
for i in range(n):
x[i] -= X
x[i] = abs(x[i])
def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
def gcd_list(n):
return reduce(gcd, n)
print((gcd_list(x))) | from functools import reduce
def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
def gcd_list(n):
return reduce(gcd, n)
n, X = list(map(int, input().split()))
x = list(map(int, input().split()))
dx = [abs(X - i) for i in x]
print((gcd_list(dx))) | 17 | 14 | 305 | 277 | from functools import reduce
n, X = list(map(int, input().split()))
x = list(map(int, input().split()))
for i in range(n):
x[i] -= X
x[i] = abs(x[i])
def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
def gcd_list(n):
return reduce(gcd, n)
print((gcd_list(x)))
| from functools import reduce
def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
def gcd_list(n):
return reduce(gcd, n)
n, X = list(map(int, input().split()))
x = list(map(int, input().split()))
dx = [abs(X - i) for i in x]
print((gcd_list(dx)))
| false | 17.647059 | [
"-",
"-n, X = list(map(int, input().split()))",
"-x = list(map(int, input().split()))",
"-for i in range(n):",
"- x[i] -= X",
"- x[i] = abs(x[i])",
"-print((gcd_list(x)))",
"+n, X = list(map(int, input().split()))",
"+x = list(map(int, input().split()))",
"+dx = [abs(X - i) for i in x]",
"+print((gcd_list(dx)))"
] | false | 0.043794 | 0.042122 | 1.039689 | [
"s221422158",
"s093736633"
] |
u803617136 | p03425 | python | s145319642 | s585243697 | 474 | 203 | 45,160 | 3,316 | Accepted | Accepted | 57.17 | N = int(eval(input()))
names = [0] * 5
pattern = []
def make_pattern(arr, cnt):
if len(arr) == 5:
if cnt == 3 :
pattern.append(arr)
return
make_pattern(arr + '1', cnt + 1)
make_pattern(arr + '0', cnt)
for _ in range(N):
name = eval(input())
initial = name[0]
if 'M' == initial:
names[0] += 1
elif 'A' == initial:
names[1] += 1
elif 'R' == initial:
names[2] += 1
elif 'C' == initial:
names[3] += 1
elif 'H' == initial:
names[4] += 1
else:
continue
make_pattern('', 0)
ans = 0
for p in pattern:
ret = 1
for i in range(5):
if p[i] == '1':
ret *= names[i]
ans += ret
print(ans)
| from collections import defaultdict
n = int(eval(input()))
h = 'MARCH'
d = [0] * 5
for _ in range(n):
s = eval(input())
if s[0] in h:
d[h.find(s[0])] += 1
ans = 0
for i in range(5):
for j in range(i, 5):
if i == j:
continue
for k in range(j, 5):
if i == k or j == k:
continue
ans += d[i] * d[j] * d[k]
print(ans)
| 38 | 19 | 756 | 408 | N = int(eval(input()))
names = [0] * 5
pattern = []
def make_pattern(arr, cnt):
if len(arr) == 5:
if cnt == 3:
pattern.append(arr)
return
make_pattern(arr + "1", cnt + 1)
make_pattern(arr + "0", cnt)
for _ in range(N):
name = eval(input())
initial = name[0]
if "M" == initial:
names[0] += 1
elif "A" == initial:
names[1] += 1
elif "R" == initial:
names[2] += 1
elif "C" == initial:
names[3] += 1
elif "H" == initial:
names[4] += 1
else:
continue
make_pattern("", 0)
ans = 0
for p in pattern:
ret = 1
for i in range(5):
if p[i] == "1":
ret *= names[i]
ans += ret
print(ans)
| from collections import defaultdict
n = int(eval(input()))
h = "MARCH"
d = [0] * 5
for _ in range(n):
s = eval(input())
if s[0] in h:
d[h.find(s[0])] += 1
ans = 0
for i in range(5):
for j in range(i, 5):
if i == j:
continue
for k in range(j, 5):
if i == k or j == k:
continue
ans += d[i] * d[j] * d[k]
print(ans)
| false | 50 | [
"-N = int(eval(input()))",
"-names = [0] * 5",
"-pattern = []",
"+from collections import defaultdict",
"-",
"-def make_pattern(arr, cnt):",
"- if len(arr) == 5:",
"- if cnt == 3:",
"- pattern.append(arr)",
"- return",
"- make_pattern(arr + \"1\", cnt + 1)",
"- make_pattern(arr + \"0\", cnt)",
"-",
"-",
"-for _ in range(N):",
"- name = eval(input())",
"- initial = name[0]",
"- if \"M\" == initial:",
"- names[0] += 1",
"- elif \"A\" == initial:",
"- names[1] += 1",
"- elif \"R\" == initial:",
"- names[2] += 1",
"- elif \"C\" == initial:",
"- names[3] += 1",
"- elif \"H\" == initial:",
"- names[4] += 1",
"- else:",
"- continue",
"-make_pattern(\"\", 0)",
"+n = int(eval(input()))",
"+h = \"MARCH\"",
"+d = [0] * 5",
"+for _ in range(n):",
"+ s = eval(input())",
"+ if s[0] in h:",
"+ d[h.find(s[0])] += 1",
"-for p in pattern:",
"- ret = 1",
"- for i in range(5):",
"- if p[i] == \"1\":",
"- ret *= names[i]",
"- ans += ret",
"+for i in range(5):",
"+ for j in range(i, 5):",
"+ if i == j:",
"+ continue",
"+ for k in range(j, 5):",
"+ if i == k or j == k:",
"+ continue",
"+ ans += d[i] * d[j] * d[k]"
] | false | 0.059993 | 0.038474 | 1.559311 | [
"s145319642",
"s585243697"
] |
u023958502 | p02757 | python | s047152503 | s222955602 | 486 | 251 | 6,560 | 3,500 | Accepted | Accepted | 48.35 | n, p = list(map(int, input().split()))
s = list(map(int, list(eval(input()))))[::-1]
sum = 0
cnt = [0] * p
cnt[0] = 1
ans = 0
if p in [2, 5]:
if p == 2:
ok_list = [0, 2, 4, 6, 8]
if p == 5:
ok_list = [0, 5]
for i in range(n):
d = s[i]
if d in ok_list:
ans += n - i
else:
for i in range(n):
d = s[i] * pow(10, i, p)
sum = (sum + d) % p
cnt[sum] += 1
for i in range(p):
ans += cnt[i] * (cnt[i]-1) // 2
print(ans)
| n, P = list(map(int, input().split()))
S = eval(input())
ans = 0
#----------------------------------------------
# 1.
# int(S[a:b]) * 10 ** (n - b) == (int(S[a: n]) - int(S[b: n])) で表される
# 例
# S = 1234
# a = 1, b = 3 のとき
# 23 = (234 - 4) // 10 ** (4 - 3)
# = 230 // 10
# = 23
#
# 2.
# Pは素数のため P = 2, 5 のとき以外は １０の約数でない
# A * (10 ** x) が Pで割れるとき A は P の倍数 (x は任意定数)
#
# 3.
# 1. の式を mod P で考える
# int(S[a: b]) * 10 ** (n - b) == (int(S[a: n]) - int(S[b: n]))
# ⇒ (S[a: b] * 10 ** (n - b)) % P == (S[a: n] - S[b: n]) % P (mod P)
# ⇒ (S[a: b] % P) * (10 ** (n - b) % P) == (S[a: n] % P) - (S[b: n] % P) (mod P)
# 2.より P = 2, 5以外のときは 10 ** (n - b) % P != 0となるため
# (S[a: n] % P) - (S[b: n] % P) = 0 すなわち (S[a: n] % P) == (S[b: n] % P)のとき
# S[a:b] % P = 0である
#
# これより
# S[i: n] % P (0 <= i < n) を求めれば
# 以下のコードのようにS[i: j] % P を求めることができる (0 <= i < n, i <= j < n)
#----------------------------------------------
#まずS[i: n] % P (0 <= i < n) を求める (remain に格納する)
remain = [0] * P
remain[0] += 1
d = 1
left = 0
for i in range(n):
# print(left)
left = (left + int(S[n - i - 1]) * d) % P
remain[left] += 1
d = d * 10 % P
# print(remain)
for r in remain:
ans += r * (r - 1) // 2
#----------------------------------------------
# 4.P = 2, 5 のときについて考える
# 1. P = 2 のとき
# ある数の下１桁が2の倍数のとき、その数は2の倍数であるため
# S[i] % 2 == 0 のとき
# S[h:i] % 2 == 0 (0 <= h <= i)
# よって以下のようなコードで答えを求めることができる
#----------------------------------------------
if P == 2:
ans = 0
for i in range(n):
if int(S[i]) % 2 == 0:
ans += i + 1
print(ans)
#----------------------------------------------
# 2. P = 5 のときもP = 2 のときと同様に考えれば良いため
#----------------------------------------------
if P == 5:
ans = 0
for i in range(n):
if int(S[i]) % 5 == 0:
ans += i + 1
print(ans)
if P != 2 and P != 5:
print(ans)
| 27 | 68 | 525 | 1,932 | n, p = list(map(int, input().split()))
s = list(map(int, list(eval(input()))))[::-1]
sum = 0
cnt = [0] * p
cnt[0] = 1
ans = 0
if p in [2, 5]:
if p == 2:
ok_list = [0, 2, 4, 6, 8]
if p == 5:
ok_list = [0, 5]
for i in range(n):
d = s[i]
if d in ok_list:
ans += n - i
else:
for i in range(n):
d = s[i] * pow(10, i, p)
sum = (sum + d) % p
cnt[sum] += 1
for i in range(p):
ans += cnt[i] * (cnt[i] - 1) // 2
print(ans)
| n, P = list(map(int, input().split()))
S = eval(input())
ans = 0
# ----------------------------------------------
# 1.
# int(S[a:b]) * 10 ** (n - b) == (int(S[a: n]) - int(S[b: n])) で表される
# 例
# S = 1234
# a = 1, b = 3 のとき
# 23 = (234 - 4) // 10 ** (4 - 3)
# = 230 // 10
# = 23
#
# 2.
# Pは素数のため P = 2, 5 のとき以外は １０の約数でない
# A * (10 ** x) が Pで割れるとき A は P の倍数 (x は任意定数)
#
# 3.
# 1. の式を mod P で考える
# int(S[a: b]) * 10 ** (n - b) == (int(S[a: n]) - int(S[b: n]))
# ⇒ (S[a: b] * 10 ** (n - b)) % P == (S[a: n] - S[b: n]) % P (mod P)
# ⇒ (S[a: b] % P) * (10 ** (n - b) % P) == (S[a: n] % P) - (S[b: n] % P) (mod P)
# 2.より P = 2, 5以外のときは 10 ** (n - b) % P != 0となるため
# (S[a: n] % P) - (S[b: n] % P) = 0 すなわち (S[a: n] % P) == (S[b: n] % P)のとき
# S[a:b] % P = 0である
#
# これより
# S[i: n] % P (0 <= i < n) を求めれば
# 以下のコードのようにS[i: j] % P を求めることができる (0 <= i < n, i <= j < n)
# ----------------------------------------------
# まずS[i: n] % P (0 <= i < n) を求める (remain に格納する)
remain = [0] * P
remain[0] += 1
d = 1
left = 0
for i in range(n):
# print(left)
left = (left + int(S[n - i - 1]) * d) % P
remain[left] += 1
d = d * 10 % P
# print(remain)
for r in remain:
ans += r * (r - 1) // 2
# ----------------------------------------------
# 4.P = 2, 5 のときについて考える
# 1. P = 2 のとき
# ある数の下１桁が2の倍数のとき、その数は2の倍数であるため
# S[i] % 2 == 0 のとき
# S[h:i] % 2 == 0 (0 <= h <= i)
# よって以下のようなコードで答えを求めることができる
# ----------------------------------------------
if P == 2:
ans = 0
for i in range(n):
if int(S[i]) % 2 == 0:
ans += i + 1
print(ans)
# ----------------------------------------------
# 2. P = 5 のときもP = 2 のときと同様に考えれば良いため
# ----------------------------------------------
if P == 5:
ans = 0
for i in range(n):
if int(S[i]) % 5 == 0:
ans += i + 1
print(ans)
if P != 2 and P != 5:
print(ans)
| false | 60.294118 | [
"-n, p = list(map(int, input().split()))",
"-s = list(map(int, list(eval(input()))))[::-1]",
"-sum = 0",
"-cnt = [0] * p",
"-cnt[0] = 1",
"+n, P = list(map(int, input().split()))",
"+S = eval(input())",
"-if p in [2, 5]:",
"- if p == 2:",
"- ok_list = [0, 2, 4, 6, 8]",
"- if p == 5:",
"- ok_list = [0, 5]",
"+# 1.",
"+# int(S[a:b]) * 10 ** (n - b) == (int(S[a: n]) - int(S[b: n])) で表される",
"+# 例",
"+# S = 1234",
"+# a = 1, b = 3 のとき",
"+# 23 = (234 - 4) // 10 ** (4 - 3)",
"+# = 230 // 10",
"+# = 23",
"+#",
"+# 2.",
"+# Pは素数のため P = 2, 5 のとき以外は １０の約数でない",
"+# A * (10 ** x) が Pで割れるとき A は P の倍数 (x は任意定数)",
"+#",
"+# 3.",
"+# 1. の式を mod P で考える",
"+# int(S[a: b]) * 10 ** (n - b) == (int(S[a: n]) - int(S[b: n]))",
"+# ⇒ (S[a: b] * 10 ** (n - b)) % P == (S[a: n] - S[b: n]) % P (mod P)",
"+# ⇒ (S[a: b] % P) * (10 ** (n - b) % P) == (S[a: n] % P) - (S[b: n] % P) (mod P)",
"+# 2.より P = 2, 5以外のときは 10 ** (n - b) % P != 0となるため",
"+# (S[a: n] % P) - (S[b: n] % P) = 0 すなわち (S[a: n] % P) == (S[b: n] % P)のとき",
"+# S[a:b] % P = 0である",
"+#",
"+# これより",
"+# S[i: n] % P (0 <= i < n) を求めれば",
"+# 以下のコードのようにS[i: j] % P を求めることができる (0 <= i < n, i <= j < n)",
"+# まずS[i: n] % P (0 <= i < n) を求める (remain に格納する)",
"+remain = [0] * P",
"+remain[0] += 1",
"+d = 1",
"+left = 0",
"+for i in range(n):",
"+ # print(left)",
"+ left = (left + int(S[n - i - 1]) * d) % P",
"+ remain[left] += 1",
"+ d = d * 10 % P",
"+# print(remain)",
"+for r in remain:",
"+ ans += r * (r - 1) // 2",
"+# 4.P = 2, 5 のときについて考える",
"+# 1. P = 2 のとき",
"+# ある数の下１桁が2の倍数のとき、その数は2の倍数であるため",
"+# S[i] % 2 == 0 のとき",
"+# S[h:i] % 2 == 0 (0 <= h <= i)",
"+# よって以下のようなコードで答えを求めることができる",
"+if P == 2:",
"+ ans = 0",
"- d = s[i]",
"- if d in ok_list:",
"- ans += n - i",
"-else:",
"+ if int(S[i]) % 2 == 0:",
"+ ans += i + 1",
"+ print(ans)",
"+# 2. P = 5 のときもP = 2 のときと同様に考えれば良いため",
"+if P == 5:",
"+ ans = 0",
"- d = s[i] * pow(10, i, p)",
"- sum = (sum + d) % p",
"- cnt[sum] += 1",
"- for i in range(p):",
"- ans += cnt[i] * (cnt[i] - 1) // 2",
"-print(ans)",
"+ if int(S[i]) % 5 == 0:",
"+ ans += i + 1",
"+ print(ans)",
"+if P != 2 and P != 5:",
"+ print(ans)"
] | false | 0.077777 | 0.085868 | 0.905774 | [
"s047152503",
"s222955602"
] |
u864197622 | p03450 | python | s946129013 | s266033680 | 1,657 | 1,121 | 108,704 | 79,904 | Accepted | Accepted | 32.35 | N, M = list(map(int, input().split()))
P = [i for i in range(N)]
D = [0] * N
C = [1] * N
def par(a):
if a == P[a]:
return a
p = par(P[a])
d = D[P[a]]
P[a] = p
D[a] += d
return p
def dist(a, b):
pa = par(a)
pb = par(b)
if pa == pb:
return D[b] - D[a]
return 1 << 30
def unite(a, b, d):
if par(a) == par(b):
return
if C[P[a]] < C[P[b]]:
a, b, d = b, a, -d
C[P[a]] += C[P[b]]
D[P[b]] = D[a] + d - D[b]
P[P[b]] = P[a]
for _ in range(M):
l, r, d = list(map(int, input().split()))
l, r = l-1, r-1
dd = dist(l, r)
if dd == 1<<30:
unite(l, r, d)
else:
if d != dd:
print("No")
break
else:
print("Yes") | from collections import deque
N, M = list(map(int, input().split()))
X = [[] for _ in range(N)]
for _ in range(M):
l, r, d = list(map(int, input().split()))
X[l-1].append((r-1, d))
X[r-1].append((l-1, -d))
done = [0] * N
dist = [0] * N
def BFS(i):
Q = deque([i])
done[i] = 1
while Q:
x = Q.popleft()
for y, d in X[x]:
if done[y]:
if dist[y] != dist[x] + d:
return 0
else:
done[y] = 1
dist[y] = dist[x] + d
Q.append(y)
return 1
for i in range(N):
if done[i] == 0:
if BFS(i) == 0:
print("No")
break
else:
print("Yes") | 42 | 32 | 781 | 728 | N, M = list(map(int, input().split()))
P = [i for i in range(N)]
D = [0] * N
C = [1] * N
def par(a):
if a == P[a]:
return a
p = par(P[a])
d = D[P[a]]
P[a] = p
D[a] += d
return p
def dist(a, b):
pa = par(a)
pb = par(b)
if pa == pb:
return D[b] - D[a]
return 1 << 30
def unite(a, b, d):
if par(a) == par(b):
return
if C[P[a]] < C[P[b]]:
a, b, d = b, a, -d
C[P[a]] += C[P[b]]
D[P[b]] = D[a] + d - D[b]
P[P[b]] = P[a]
for _ in range(M):
l, r, d = list(map(int, input().split()))
l, r = l - 1, r - 1
dd = dist(l, r)
if dd == 1 << 30:
unite(l, r, d)
else:
if d != dd:
print("No")
break
else:
print("Yes")
| from collections import deque
N, M = list(map(int, input().split()))
X = [[] for _ in range(N)]
for _ in range(M):
l, r, d = list(map(int, input().split()))
X[l - 1].append((r - 1, d))
X[r - 1].append((l - 1, -d))
done = [0] * N
dist = [0] * N
def BFS(i):
Q = deque([i])
done[i] = 1
while Q:
x = Q.popleft()
for y, d in X[x]:
if done[y]:
if dist[y] != dist[x] + d:
return 0
else:
done[y] = 1
dist[y] = dist[x] + d
Q.append(y)
return 1
for i in range(N):
if done[i] == 0:
if BFS(i) == 0:
print("No")
break
else:
print("Yes")
| false | 23.809524 | [
"+from collections import deque",
"+",
"-P = [i for i in range(N)]",
"-D = [0] * N",
"-C = [1] * N",
"+X = [[] for _ in range(N)]",
"+for _ in range(M):",
"+ l, r, d = list(map(int, input().split()))",
"+ X[l - 1].append((r - 1, d))",
"+ X[r - 1].append((l - 1, -d))",
"+done = [0] * N",
"+dist = [0] * N",
"-def par(a):",
"- if a == P[a]:",
"- return a",
"- p = par(P[a])",
"- d = D[P[a]]",
"- P[a] = p",
"- D[a] += d",
"- return p",
"+def BFS(i):",
"+ Q = deque([i])",
"+ done[i] = 1",
"+ while Q:",
"+ x = Q.popleft()",
"+ for y, d in X[x]:",
"+ if done[y]:",
"+ if dist[y] != dist[x] + d:",
"+ return 0",
"+ else:",
"+ done[y] = 1",
"+ dist[y] = dist[x] + d",
"+ Q.append(y)",
"+ return 1",
"-def dist(a, b):",
"- pa = par(a)",
"- pb = par(b)",
"- if pa == pb:",
"- return D[b] - D[a]",
"- return 1 << 30",
"-",
"-",
"-def unite(a, b, d):",
"- if par(a) == par(b):",
"- return",
"- if C[P[a]] < C[P[b]]:",
"- a, b, d = b, a, -d",
"- C[P[a]] += C[P[b]]",
"- D[P[b]] = D[a] + d - D[b]",
"- P[P[b]] = P[a]",
"-",
"-",
"-for _ in range(M):",
"- l, r, d = list(map(int, input().split()))",
"- l, r = l - 1, r - 1",
"- dd = dist(l, r)",
"- if dd == 1 << 30:",
"- unite(l, r, d)",
"- else:",
"- if d != dd:",
"+for i in range(N):",
"+ if done[i] == 0:",
"+ if BFS(i) == 0:"
] | false | 0.05929 | 0.074729 | 0.793411 | [
"s946129013",
"s266033680"
] |
u535803878 | p02579 | python | s226237237 | s103206465 | 1,784 | 1,463 | 98,736 | 104,504 | Accepted | Accepted | 17.99 | import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
h,w = list(map(int, input().split()))
ch,cw = list(map(int, input().split()))
dh,dw = list(map(int, input().split()))
ch -= 1
cw -= 1
dh -= 1
dw -= 1
rows,cols = h,w
OK = "."
NG = "#"
from collections import defaultdict
ns = defaultdict(set)
ss = [None] * rows
for i in range(rows):
s = eval(input())
ss[i] = s
n = rows * cols
start = ch*w+cw
goal = dh*w+dw
seen = [None]*n
seen[start] = 0
from queue import deque
q = deque([(0, start)]) # ワープ回数, 現在位置, 最後の道の位置
# dx = [0,1,0,-1]
# dy = [1,0,-1,0]
dx = []
dy = []
vvs = []
for i in range(-2,3):
for j in range(-2,3):
if not (i==j==0):
dx.append(i)
dy.append(j)
if abs(i)+abs(j)>1:
vvs.append(1)
else:
vvs.append(0)
while q:
pnum,pu = q.popleft()
ux,uy = divmod(pu,w)
# print(pnum,divmod(pu,w))
if pu==goal:
break
for xx,yy,vv in zip(dx,dy,vvs):
# x = ux+xx
# y = uy+yy
x,y = ux+xx, uy+yy
u = x*w + y
num = pnum+vv
if x<0 or y<0 or x>=h or y>=w or ss[x][y]=="#":
continue
# print(x,y)
if seen[u] is None or seen[u]>num:
seen[u] = num
if vv==0:
q.appendleft((num, u))
else:
q.append((num,u))
val = seen[goal]
if val is None:
print((-1))
else:
print(val) | import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
h,w = list(map(int, input().split()))
ch,cw = list(map(int, input().split()))
dh,dw = list(map(int, input().split()))
ch -= 1
cw -= 1
dh -= 1
dw -= 1
rows,cols = h,w
OK = "."
NG = "#"
from collections import defaultdict, deque
ns = defaultdict(set)
ss = [None] * rows
for i in range(rows):
s = eval(input())
ss[i] = s
n = rows * cols
start = ch*w+cw
goal = dh*w+dw
seen = [None]*n
seen[start] = 0
q = deque([(0, start)]) # ワープ回数, 現在位置, 最後の道の位置
# dx = [0,1,0,-1]
# dy = [1,0,-1,0]
dx = []
dy = []
vvs = []
for i in range(-2,3):
for j in range(-2,3):
if not (i==j==0):
dx.append(i)
dy.append(j)
if abs(i)+abs(j)>1:
vvs.append(1)
else:
vvs.append(0)
while q:
pnum,pu = q.popleft()
ux,uy = divmod(pu,w)
# print(pnum,divmod(pu,w))
if pu==goal:
break
for xx,yy,vv in zip(dx,dy,vvs):
# x = ux+xx
# y = uy+yy
x,y = ux+xx, uy+yy
u = x*w + y
num = pnum+vv
if x<0 or y<0 or x>=h or y>=w or ss[x][y]=="#":
continue
# print(x,y)
if seen[u] is None or seen[u]>num:
seen[u] = num
if vv==0:
q.appendleft((num, u))
else:
q.append((num,u))
val = seen[goal]
if val is None:
print((-1))
else:
print(val) | 72 | 72 | 1,572 | 1,555 | import sys
input = lambda: sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x + "\n")
h, w = list(map(int, input().split()))
ch, cw = list(map(int, input().split()))
dh, dw = list(map(int, input().split()))
ch -= 1
cw -= 1
dh -= 1
dw -= 1
rows, cols = h, w
OK = "."
NG = "#"
from collections import defaultdict
ns = defaultdict(set)
ss = [None] * rows
for i in range(rows):
s = eval(input())
ss[i] = s
n = rows * cols
start = ch * w + cw
goal = dh * w + dw
seen = [None] * n
seen[start] = 0
from queue import deque
q = deque([(0, start)]) # ワープ回数, 現在位置, 最後の道の位置
# dx = [0,1,0,-1]
# dy = [1,0,-1,0]
dx = []
dy = []
vvs = []
for i in range(-2, 3):
for j in range(-2, 3):
if not (i == j == 0):
dx.append(i)
dy.append(j)
if abs(i) + abs(j) > 1:
vvs.append(1)
else:
vvs.append(0)
while q:
pnum, pu = q.popleft()
ux, uy = divmod(pu, w)
# print(pnum,divmod(pu,w))
if pu == goal:
break
for xx, yy, vv in zip(dx, dy, vvs):
# x = ux+xx
# y = uy+yy
x, y = ux + xx, uy + yy
u = x * w + y
num = pnum + vv
if x < 0 or y < 0 or x >= h or y >= w or ss[x][y] == "#":
continue
# print(x,y)
if seen[u] is None or seen[u] > num:
seen[u] = num
if vv == 0:
q.appendleft((num, u))
else:
q.append((num, u))
val = seen[goal]
if val is None:
print((-1))
else:
print(val)
| import sys
input = lambda: sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x + "\n")
h, w = list(map(int, input().split()))
ch, cw = list(map(int, input().split()))
dh, dw = list(map(int, input().split()))
ch -= 1
cw -= 1
dh -= 1
dw -= 1
rows, cols = h, w
OK = "."
NG = "#"
from collections import defaultdict, deque
ns = defaultdict(set)
ss = [None] * rows
for i in range(rows):
s = eval(input())
ss[i] = s
n = rows * cols
start = ch * w + cw
goal = dh * w + dw
seen = [None] * n
seen[start] = 0
q = deque([(0, start)]) # ワープ回数, 現在位置, 最後の道の位置
# dx = [0,1,0,-1]
# dy = [1,0,-1,0]
dx = []
dy = []
vvs = []
for i in range(-2, 3):
for j in range(-2, 3):
if not (i == j == 0):
dx.append(i)
dy.append(j)
if abs(i) + abs(j) > 1:
vvs.append(1)
else:
vvs.append(0)
while q:
pnum, pu = q.popleft()
ux, uy = divmod(pu, w)
# print(pnum,divmod(pu,w))
if pu == goal:
break
for xx, yy, vv in zip(dx, dy, vvs):
# x = ux+xx
# y = uy+yy
x, y = ux + xx, uy + yy
u = x * w + y
num = pnum + vv
if x < 0 or y < 0 or x >= h or y >= w or ss[x][y] == "#":
continue
# print(x,y)
if seen[u] is None or seen[u] > num:
seen[u] = num
if vv == 0:
q.appendleft((num, u))
else:
q.append((num, u))
val = seen[goal]
if val is None:
print((-1))
else:
print(val)
| false | 0 | [
"-from collections import defaultdict",
"+from collections import defaultdict, deque",
"-from queue import deque",
"-"
] | false | 0.044743 | 0.105249 | 0.425121 | [
"s226237237",
"s103206465"
] |
u971811058 | p03730 | python | s124312915 | s461573744 | 33 | 30 | 9,516 | 9,388 | Accepted | Accepted | 9.09 | # Begin Header {{{
from math import gcd
from collections import Counter, deque, defaultdict
from heapq import heappush, heappop, heappushpop, heapify, heapreplace, merge
from bisect import bisect_left, bisect_right, bisect, insort_left, insort_right, insort
from itertools import accumulate, product, permutations, combinations, combinations_with_replacement
# }}} End Header
# _________コーディングはここから！！___________
# ... 最小側の制約も確認した？
# ... オーバーフローしない？
a, b, c = list(map(int, input().split()))
i = 1
while i<=b:
if (a*i-c)%b != 0: i+=1
else:
print("YES")
exit()
print("NO") | # Begin Header {{{
from math import gcd
from collections import Counter, deque, defaultdict
from heapq import heappush, heappop, heappushpop, heapify, heapreplace, merge
from bisect import bisect_left, bisect_right, bisect, insort_left, insort_right, insort
from itertools import accumulate, product, permutations, combinations, combinations_with_replacement
# }}} End Header
# _________コーディングはここから！！___________
# ... 最小側の制約も確認した？
# ... オーバーフローしない？
a, b, c = list(map(int, input().split()))
for i in range(1, b+1):
if (a*i-c)%b: i+=1
else:
print("YES")
exit()
print("NO") | 18 | 17 | 605 | 605 | # Begin Header {{{
from math import gcd
from collections import Counter, deque, defaultdict
from heapq import heappush, heappop, heappushpop, heapify, heapreplace, merge
from bisect import bisect_left, bisect_right, bisect, insort_left, insort_right, insort
from itertools import (
accumulate,
product,
permutations,
combinations,
combinations_with_replacement,
)
# }}} End Header
# _________コーディングはここから！！___________
# ... 最小側の制約も確認した？
# ... オーバーフローしない？
a, b, c = list(map(int, input().split()))
i = 1
while i <= b:
if (a * i - c) % b != 0:
i += 1
else:
print("YES")
exit()
print("NO")
| # Begin Header {{{
from math import gcd
from collections import Counter, deque, defaultdict
from heapq import heappush, heappop, heappushpop, heapify, heapreplace, merge
from bisect import bisect_left, bisect_right, bisect, insort_left, insort_right, insort
from itertools import (
accumulate,
product,
permutations,
combinations,
combinations_with_replacement,
)
# }}} End Header
# _________コーディングはここから！！___________
# ... 最小側の制約も確認した？
# ... オーバーフローしない？
a, b, c = list(map(int, input().split()))
for i in range(1, b + 1):
if (a * i - c) % b:
i += 1
else:
print("YES")
exit()
print("NO")
| false | 5.555556 | [
"-i = 1",
"-while i <= b:",
"- if (a * i - c) % b != 0:",
"+for i in range(1, b + 1):",
"+ if (a * i - c) % b:"
] | false | 0.069346 | 0.0376 | 1.844292 | [
"s124312915",
"s461573744"
] |
u347640436 | p02732 | python | s776941160 | s209291604 | 384 | 344 | 25,716 | 26,140 | Accepted | Accepted | 10.42 | N = int(eval(input()))
A = list(map(int, input().split()))
d = {}
for a in A:
if a in d:
d[a] += 1
else:
d[a] = 1
s = 0
for k in d:
s += d[k] * (d[k] - 1) // 2
for i in range(N):
t = d[A[i]]
print((s - t * (t - 1) // 2 + (t - 1) * (t - 2) // 2))
| N = int(eval(input()))
A = list(map(int, input().split()))
d = {}
for a in A:
if a in d:
d[a] += 1
else:
d[a] = 1
s = 0
for k in d:
s += d[k] * (d[k] - 1) // 2
for i in range(N):
print((s - d[A[i]] + 1))
| 17 | 16 | 293 | 246 | N = int(eval(input()))
A = list(map(int, input().split()))
d = {}
for a in A:
if a in d:
d[a] += 1
else:
d[a] = 1
s = 0
for k in d:
s += d[k] * (d[k] - 1) // 2
for i in range(N):
t = d[A[i]]
print((s - t * (t - 1) // 2 + (t - 1) * (t - 2) // 2))
| N = int(eval(input()))
A = list(map(int, input().split()))
d = {}
for a in A:
if a in d:
d[a] += 1
else:
d[a] = 1
s = 0
for k in d:
s += d[k] * (d[k] - 1) // 2
for i in range(N):
print((s - d[A[i]] + 1))
| false | 5.882353 | [
"- t = d[A[i]]",
"- print((s - t * (t - 1) // 2 + (t - 1) * (t - 2) // 2))",
"+ print((s - d[A[i]] + 1))"
] | false | 0.038749 | 0.102584 | 0.377733 | [
"s776941160",
"s209291604"
] |
u553987207 | p02756 | python | s552809961 | s419483126 | 395 | 126 | 5,736 | 14,128 | Accepted | Accepted | 68.1 | S = eval(input())
Q = int(eval(input()))
f = True
l = []
r = []
for _ in range(Q):
q = eval(input())
if q == "1":
f = not f
else:
_, F, C = q.split()
if F == "1":
t = l if f else r
t.append(C)
else:
t = r if f else l
t.append(C)
if f:
l.reverse()
ans = "".join(l) + S + "".join(r)
else:
r.reverse()
ans = "".join(r) + S[::-1] + "".join(l)
print(ans) | import sys
from collections import deque
S = deque(eval(input()))
Q = int(eval(input()))
reverse = False
for _ in range(Q):
q = sys.stdin.readline()
if q[0] == "1":
reverse = not reverse
else:
_, f, c = q.split()
if f == "1":
if reverse:
S.append(c)
else:
S.appendleft(c)
else:
if reverse:
S.appendleft(c)
else:
S.append(c)
if reverse:
S.reverse()
ans = "".join(S)
print(ans) | 24 | 26 | 462 | 549 | S = eval(input())
Q = int(eval(input()))
f = True
l = []
r = []
for _ in range(Q):
q = eval(input())
if q == "1":
f = not f
else:
_, F, C = q.split()
if F == "1":
t = l if f else r
t.append(C)
else:
t = r if f else l
t.append(C)
if f:
l.reverse()
ans = "".join(l) + S + "".join(r)
else:
r.reverse()
ans = "".join(r) + S[::-1] + "".join(l)
print(ans)
| import sys
from collections import deque
S = deque(eval(input()))
Q = int(eval(input()))
reverse = False
for _ in range(Q):
q = sys.stdin.readline()
if q[0] == "1":
reverse = not reverse
else:
_, f, c = q.split()
if f == "1":
if reverse:
S.append(c)
else:
S.appendleft(c)
else:
if reverse:
S.appendleft(c)
else:
S.append(c)
if reverse:
S.reverse()
ans = "".join(S)
print(ans)
| false | 7.692308 | [
"-S = eval(input())",
"+import sys",
"+from collections import deque",
"+",
"+S = deque(eval(input()))",
"-f = True",
"-l = []",
"-r = []",
"+reverse = False",
"- q = eval(input())",
"- if q == \"1\":",
"- f = not f",
"+ q = sys.stdin.readline()",
"+ if q[0] == \"1\":",
"+ reverse = not reverse",
"- _, F, C = q.split()",
"- if F == \"1\":",
"- t = l if f else r",
"- t.append(C)",
"+ _, f, c = q.split()",
"+ if f == \"1\":",
"+ if reverse:",
"+ S.append(c)",
"+ else:",
"+ S.appendleft(c)",
"- t = r if f else l",
"- t.append(C)",
"-if f:",
"- l.reverse()",
"- ans = \"\".join(l) + S + \"\".join(r)",
"-else:",
"- r.reverse()",
"- ans = \"\".join(r) + S[::-1] + \"\".join(l)",
"+ if reverse:",
"+ S.appendleft(c)",
"+ else:",
"+ S.append(c)",
"+if reverse:",
"+ S.reverse()",
"+ans = \"\".join(S)"
] | false | 0.079698 | 0.037974 | 2.098735 | [
"s552809961",
"s419483126"
] |
u636683284 | p02573 | python | s735631318 | s238502255 | 1,367 | 504 | 133,748 | 90,392 | Accepted | Accepted | 63.13 | from collections import defaultdict,deque
n,m = list(map(int,input().split()))
d = defaultdict(list)
if m==0:
print((1))
exit()
visited = [-1] + [False]*n
for i in range(m):
a,b = list(map(int,input().split()))
d[a].append(b)
d[b].append(a)
maxi = 1
for i in range(1,n+1):
if visited[i]:
continue
cnt = 0
que = deque([i])
while que:
v = que.pop()
if not visited[v]:
visited[v] = True
cnt += 1
for j in d[v]:
if not visited[j]:
que.append(j)
maxi = max(maxi,cnt)
print(maxi) | class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n+1)]
self.rank = [0] * (n+1)
self.size = [1] * (n+1)
# 検索
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
# 併合
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.rank[x] < self.rank[y]:
self.par[x] = y
self.size[y] += self.size[x]
else:
self.par[y] = x
self.size[x] += self.size[y]
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
# 同じ集合に属するか判定
def same_check(self, x, y):
return self.find(x) == self.find(y)
n,m = list(map(int,input().split()))
uf = UnionFind(n)
for i in range(m):
a,b = list(map(int,input().split()))
uf.union(a,b)
print((max(uf.size))) | 30 | 40 | 615 | 1,004 | from collections import defaultdict, deque
n, m = list(map(int, input().split()))
d = defaultdict(list)
if m == 0:
print((1))
exit()
visited = [-1] + [False] * n
for i in range(m):
a, b = list(map(int, input().split()))
d[a].append(b)
d[b].append(a)
maxi = 1
for i in range(1, n + 1):
if visited[i]:
continue
cnt = 0
que = deque([i])
while que:
v = que.pop()
if not visited[v]:
visited[v] = True
cnt += 1
for j in d[v]:
if not visited[j]:
que.append(j)
maxi = max(maxi, cnt)
print(maxi)
| class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n + 1)]
self.rank = [0] * (n + 1)
self.size = [1] * (n + 1)
# 検索
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
# 併合
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.rank[x] < self.rank[y]:
self.par[x] = y
self.size[y] += self.size[x]
else:
self.par[y] = x
self.size[x] += self.size[y]
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
# 同じ集合に属するか判定
def same_check(self, x, y):
return self.find(x) == self.find(y)
n, m = list(map(int, input().split()))
uf = UnionFind(n)
for i in range(m):
a, b = list(map(int, input().split()))
uf.union(a, b)
print((max(uf.size)))
| false | 25 | [
"-from collections import defaultdict, deque",
"+class UnionFind:",
"+ def __init__(self, n):",
"+ self.par = [i for i in range(n + 1)]",
"+ self.rank = [0] * (n + 1)",
"+ self.size = [1] * (n + 1)",
"+",
"+ # 検索",
"+ def find(self, x):",
"+ if self.par[x] == x:",
"+ return x",
"+ else:",
"+ self.par[x] = self.find(self.par[x])",
"+ return self.par[x]",
"+",
"+ # 併合",
"+ def union(self, x, y):",
"+ x = self.find(x)",
"+ y = self.find(y)",
"+ if x == y:",
"+ return",
"+ if self.rank[x] < self.rank[y]:",
"+ self.par[x] = y",
"+ self.size[y] += self.size[x]",
"+ else:",
"+ self.par[y] = x",
"+ self.size[x] += self.size[y]",
"+ if self.rank[x] == self.rank[y]:",
"+ self.rank[x] += 1",
"+",
"+ # 同じ集合に属するか判定",
"+ def same_check(self, x, y):",
"+ return self.find(x) == self.find(y)",
"+",
"-d = defaultdict(list)",
"-if m == 0:",
"- print((1))",
"- exit()",
"-visited = [-1] + [False] * n",
"+uf = UnionFind(n)",
"- d[a].append(b)",
"- d[b].append(a)",
"-maxi = 1",
"-for i in range(1, n + 1):",
"- if visited[i]:",
"- continue",
"- cnt = 0",
"- que = deque([i])",
"- while que:",
"- v = que.pop()",
"- if not visited[v]:",
"- visited[v] = True",
"- cnt += 1",
"- for j in d[v]:",
"- if not visited[j]:",
"- que.append(j)",
"- maxi = max(maxi, cnt)",
"-print(maxi)",
"+ uf.union(a, b)",
"+print((max(uf.size)))"
] | false | 0.036588 | 0.035134 | 1.041372 | [
"s735631318",
"s238502255"
] |
u844196583 | p02784 | python | s673886731 | s972617681 | 60 | 47 | 20,480 | 20,488 | Accepted | Accepted | 21.67 | H,N = list(map(int, input().split()))
data = list(map(int, input().split()))
S = 0
for i in range(0,len(data)):
S += data[i]
if H > S:
print("No")
else:
print("Yes") | H,N = list(map(int, input().split()))
data = list(map(int,input().split()))
if H <= sum(data):
print('Yes')
else:
print('No') | 10 | 8 | 181 | 136 | H, N = list(map(int, input().split()))
data = list(map(int, input().split()))
S = 0
for i in range(0, len(data)):
S += data[i]
if H > S:
print("No")
else:
print("Yes")
| H, N = list(map(int, input().split()))
data = list(map(int, input().split()))
if H <= sum(data):
print("Yes")
else:
print("No")
| false | 20 | [
"-S = 0",
"-for i in range(0, len(data)):",
"- S += data[i]",
"-if H > S:",
"+if H <= sum(data):",
"+ print(\"Yes\")",
"+else:",
"-else:",
"- print(\"Yes\")"
] | false | 0.039245 | 0.039133 | 1.002862 | [
"s673886731",
"s972617681"
] |
u499381410 | p03988 | python | s519658176 | s553289448 | 163 | 144 | 81,460 | 81,516 | Accepted | Accepted | 11.66 | from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor, acos, asin, atan, sqrt, tan, cos, pi
from operator import mul
from functools import reduce
from pprint import pprint
sys.setrecursionlimit(10 ** 7)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline().strip()
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 = 998244353
n = I()
A = LI()
D = Counter(A)
min_a = min(A)
max_a = min_a * 2 if D[min_a] == 1 else min_a * 2 - 1
if D[min_a] > 2:
print("Impossible")
exit()
flg = 0
for i in range(min_a + 1, max_a + 1):
if D[i] < 2:
print("Impossible")
exit()
D[i] -= 2
for k in list(D.keys()):
if k > max_a:
print("Impossible")
exit()
print("Possible")
| from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor, acos, asin, atan, sqrt, tan, cos, pi
from operator import mul
from functools import reduce
from pprint import pprint
sys.setrecursionlimit(10 ** 7)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline().strip()
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 = 998244353
n = I()
A = LI()
D = Counter(A)
min_a = min(A)
max_a = min_a * 2 if D[min_a] == 1 else min_a * 2 - 1
if D[min_a] > 2 or max(A) > max_a:
print("Impossible")
exit()
for i in range(min_a + 1, max_a + 1):
if D[i] < 2:
print("Impossible")
exit()
print("Possible")
| 67 | 61 | 1,429 | 1,339 | from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor, acos, asin, atan, sqrt, tan, cos, pi
from operator import mul
from functools import reduce
from pprint import pprint
sys.setrecursionlimit(10**7)
INF = 10**20
def LI():
return list(map(int, sys.stdin.readline().split()))
def I():
return int(sys.stdin.readline())
def LS():
return sys.stdin.readline().split()
def S():
return sys.stdin.readline().strip()
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 = 998244353
n = I()
A = LI()
D = Counter(A)
min_a = min(A)
max_a = min_a * 2 if D[min_a] == 1 else min_a * 2 - 1
if D[min_a] > 2:
print("Impossible")
exit()
flg = 0
for i in range(min_a + 1, max_a + 1):
if D[i] < 2:
print("Impossible")
exit()
D[i] -= 2
for k in list(D.keys()):
if k > max_a:
print("Impossible")
exit()
print("Possible")
| from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor, acos, asin, atan, sqrt, tan, cos, pi
from operator import mul
from functools import reduce
from pprint import pprint
sys.setrecursionlimit(10**7)
INF = 10**20
def LI():
return list(map(int, sys.stdin.readline().split()))
def I():
return int(sys.stdin.readline())
def LS():
return sys.stdin.readline().split()
def S():
return sys.stdin.readline().strip()
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 = 998244353
n = I()
A = LI()
D = Counter(A)
min_a = min(A)
max_a = min_a * 2 if D[min_a] == 1 else min_a * 2 - 1
if D[min_a] > 2 or max(A) > max_a:
print("Impossible")
exit()
for i in range(min_a + 1, max_a + 1):
if D[i] < 2:
print("Impossible")
exit()
print("Possible")
| false | 8.955224 | [
"-if D[min_a] > 2:",
"+if D[min_a] > 2 or max(A) > max_a:",
"-flg = 0",
"- D[i] -= 2",
"-for k in list(D.keys()):",
"- if k > max_a:",
"- print(\"Impossible\")",
"- exit()"
] | false | 0.0475 | 0.040839 | 1.163102 | [
"s519658176",
"s553289448"
] |
u599114793 | p03013 | python | s587694112 | s759991233 | 477 | 199 | 50,136 | 7,824 | Accepted | Accepted | 58.28 | n,m = list(map(int,input().split()))
stair = []
mod = int(1e9+7)
ans = 1
for i in range(m):
stair.append(int(eval(input())))
dp = [0] * (n+1)
dp[0] = dp[1] = 1
stair.append(int(1e10))
if n == 1:
print((1))
exit()
k = 0
for i in range(1, n+1):
if i == stair[k]:
dp[i] = 0
k += 1
elif i == 1:
dp[1] = 1
else:
dp[i] = (dp[i-1] + dp[i-2])%mod
print((dp[-1]))
| n,m = list(map(int,input().split()))
stair = []
mod = int(1e9+7)
for i in range(m):
stair.append(int(eval(input())))
dp = [0] * (n+1)
dp[0] = 1
stair.append(int(1e10))
k = 0
for i in range(1, n+1):
if i == stair[k]:
dp[i] = 0
k += 1
elif i == 1:
dp[1] = 1
else:
dp[i] = (dp[i-1] + dp[i-2])%mod
print((dp[-1]))
| 25 | 21 | 422 | 367 | n, m = list(map(int, input().split()))
stair = []
mod = int(1e9 + 7)
ans = 1
for i in range(m):
stair.append(int(eval(input())))
dp = [0] * (n + 1)
dp[0] = dp[1] = 1
stair.append(int(1e10))
if n == 1:
print((1))
exit()
k = 0
for i in range(1, n + 1):
if i == stair[k]:
dp[i] = 0
k += 1
elif i == 1:
dp[1] = 1
else:
dp[i] = (dp[i - 1] + dp[i - 2]) % mod
print((dp[-1]))
| n, m = list(map(int, input().split()))
stair = []
mod = int(1e9 + 7)
for i in range(m):
stair.append(int(eval(input())))
dp = [0] * (n + 1)
dp[0] = 1
stair.append(int(1e10))
k = 0
for i in range(1, n + 1):
if i == stair[k]:
dp[i] = 0
k += 1
elif i == 1:
dp[1] = 1
else:
dp[i] = (dp[i - 1] + dp[i - 2]) % mod
print((dp[-1]))
| false | 16 | [
"-ans = 1",
"-dp[0] = dp[1] = 1",
"+dp[0] = 1",
"-if n == 1:",
"- print((1))",
"- exit()"
] | false | 0.035729 | 0.038209 | 0.935086 | [
"s587694112",
"s759991233"
] |
u627417051 | p02693 | python | s244061888 | s001026062 | 82 | 71 | 64,688 | 64,936 | Accepted | Accepted | 13.41 | #設定
import sys
input = sys.stdin.buffer.readline
#ライブラリインポート
from collections import defaultdict
con = 10 ** 9 + 7
#入力受け取り
def getlist():
return list(map(int, input().split()))
#処理内容
def main():
K = int(eval(input()))
A, B = getlist()
for i in range(1001):
if A <= K * i and K * i <= B:
print("OK")
return
print("NG")
if __name__ == '__main__':
main() | import sys; input = sys.stdin.buffer.readline
from collections import defaultdict
con = 10 ** 9 + 7
def getlist():
return list(map(int, input().split()))
def main():
K = int(eval(input()))
A, B = getlist()
for i in range(1001):
if A <= K * i and K * i <= B:
print("OK")
return
print("NG")
if __name__ == '__main__':
main() | 27 | 21 | 393 | 357 | # 設定
import sys
input = sys.stdin.buffer.readline
# ライブラリインポート
from collections import defaultdict
con = 10**9 + 7
# 入力受け取り
def getlist():
return list(map(int, input().split()))
# 処理内容
def main():
K = int(eval(input()))
A, B = getlist()
for i in range(1001):
if A <= K * i and K * i <= B:
print("OK")
return
print("NG")
if __name__ == "__main__":
main()
| import sys
input = sys.stdin.buffer.readline
from collections import defaultdict
con = 10**9 + 7
def getlist():
return list(map(int, input().split()))
def main():
K = int(eval(input()))
A, B = getlist()
for i in range(1001):
if A <= K * i and K * i <= B:
print("OK")
return
print("NG")
if __name__ == "__main__":
main()
| false | 22.222222 | [
"-# 設定",
"-# ライブラリインポート",
"-# 入力受け取り",
"+",
"+",
"-# 処理内容"
] | false | 0.037125 | 0.03682 | 1.008273 | [
"s244061888",
"s001026062"
] |
u994988729 | p03038 | python | s635181510 | s274948268 | 513 | 304 | 20,984 | 22,080 | Accepted | Accepted | 40.74 | import heapq
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
heapq.heapify(a)
CB=[]
for _ in range(m):
b, c = list(map(int, input().split()))
CB.append((c, b))
CB.sort(reverse=True)
for c, b in CB:
if a[0] >= c:
break
for _ in range(b):
if a[0] >= c:
break
heapq.heappushpop(a, c)
print((sum(a))) | from operator import itemgetter
import heapq
import sys
input = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 7)
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
heapq.heapify(A)
BC = [tuple(map(int, input().split())) for _ in range(M)]
BC.sort(reverse=True, key=itemgetter(1))
for b, c in BC:
if A[0] < c:
while b:
heapq.heappushpop(A, c)
b -= 1
else:
break
print((sum(A))) | 19 | 22 | 381 | 473 | import heapq
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
heapq.heapify(a)
CB = []
for _ in range(m):
b, c = list(map(int, input().split()))
CB.append((c, b))
CB.sort(reverse=True)
for c, b in CB:
if a[0] >= c:
break
for _ in range(b):
if a[0] >= c:
break
heapq.heappushpop(a, c)
print((sum(a)))
| from operator import itemgetter
import heapq
import sys
input = sys.stdin.buffer.readline
sys.setrecursionlimit(10**7)
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
heapq.heapify(A)
BC = [tuple(map(int, input().split())) for _ in range(M)]
BC.sort(reverse=True, key=itemgetter(1))
for b, c in BC:
if A[0] < c:
while b:
heapq.heappushpop(A, c)
b -= 1
else:
break
print((sum(A)))
| false | 13.636364 | [
"+from operator import itemgetter",
"+import sys",
"-n, m = list(map(int, input().split()))",
"-a = list(map(int, input().split()))",
"-heapq.heapify(a)",
"-CB = []",
"-for _ in range(m):",
"- b, c = list(map(int, input().split()))",
"- CB.append((c, b))",
"-CB.sort(reverse=True)",
"-for c, b in CB:",
"- if a[0] >= c:",
"+input = sys.stdin.buffer.readline",
"+sys.setrecursionlimit(10**7)",
"+N, M = list(map(int, input().split()))",
"+A = list(map(int, input().split()))",
"+heapq.heapify(A)",
"+BC = [tuple(map(int, input().split())) for _ in range(M)]",
"+BC.sort(reverse=True, key=itemgetter(1))",
"+for b, c in BC:",
"+ if A[0] < c:",
"+ while b:",
"+ heapq.heappushpop(A, c)",
"+ b -= 1",
"+ else:",
"- for _ in range(b):",
"- if a[0] >= c:",
"- break",
"- heapq.heappushpop(a, c)",
"-print((sum(a)))",
"+print((sum(A)))"
] | false | 0.046536 | 0.15281 | 0.304535 | [
"s635181510",
"s274948268"
] |
u729133443 | p02574 | python | s128096912 | s849978739 | 1,480 | 1,224 | 234,532 | 100,916 | Accepted | Accepted | 17.3 | n,*a=list(map(int,open(0).read().split()))
m=6**8
c=[0]*m
p=[1,1]+c[:]
for i in range(m):
if p[i]<1:
for j in range(i,m,i):p[j]=i
for a in a:
s={a}
while a!=p[a]:
s|={p[a]}
a//=p[a]
s|={a}
for i in s:c[i]+=1
print((('not','psaeitr'[max(c[2:])>1::2]+'wise')[max(c[2:])<n],'coprime')) | import math
m=6**8
c=[g:=0]*m
for a in[*open(0)][1].split():g=math.gcd(g,a:=int(a));c[a]+=1
print((('not','psaeitr'[any(sum(c[i::i])>1for i in range(2,m))::2]+'wise')[g<2],'coprime')) | 15 | 5 | 312 | 185 | n, *a = list(map(int, open(0).read().split()))
m = 6**8
c = [0] * m
p = [1, 1] + c[:]
for i in range(m):
if p[i] < 1:
for j in range(i, m, i):
p[j] = i
for a in a:
s = {a}
while a != p[a]:
s |= {p[a]}
a //= p[a]
s |= {a}
for i in s:
c[i] += 1
print((("not", "psaeitr"[max(c[2:]) > 1 :: 2] + "wise")[max(c[2:]) < n], "coprime"))
| import math
m = 6**8
c = [g := 0] * m
for a in [*open(0)][1].split():
g = math.gcd(g, a := int(a))
c[a] += 1
print(
(
("not", "psaeitr"[any(sum(c[i::i]) > 1 for i in range(2, m)) :: 2] + "wise")[
g < 2
],
"coprime",
)
)
| false | 66.666667 | [
"-n, *a = list(map(int, open(0).read().split()))",
"+import math",
"+",
"-c = [0] * m",
"-p = [1, 1] + c[:]",
"-for i in range(m):",
"- if p[i] < 1:",
"- for j in range(i, m, i):",
"- p[j] = i",
"-for a in a:",
"- s = {a}",
"- while a != p[a]:",
"- s |= {p[a]}",
"- a //= p[a]",
"- s |= {a}",
"- for i in s:",
"- c[i] += 1",
"-print(((\"not\", \"psaeitr\"[max(c[2:]) > 1 :: 2] + \"wise\")[max(c[2:]) < n], \"coprime\"))",
"+c = [g := 0] * m",
"+for a in [*open(0)][1].split():",
"+ g = math.gcd(g, a := int(a))",
"+ c[a] += 1",
"+print(",
"+ (",
"+ (\"not\", \"psaeitr\"[any(sum(c[i::i]) > 1 for i in range(2, m)) :: 2] + \"wise\")[",
"+ g < 2",
"+ ],",
"+ \"coprime\",",
"+ )",
"+)"
] | false | 1.676046 | 1.0819 | 1.549168 | [
"s128096912",
"s849978739"
] |
u844005364 | p03329 | python | s334859652 | s839172487 | 242 | 194 | 46,168 | 42,200 | Accepted | Accepted | 19.83 | import bisect
x = int(eval(input()))
six_list = [6 ** i for i in range(7)]
nine_list = [9 ** i for i in range(6)]
def six_nine(n):
if n == 0:
return 0
else:
six = six_list[bisect.bisect_right(six_list, n) - 1]
nine = nine_list[bisect.bisect_right(nine_list, n) - 1]
return min(n // six + six_nine(n % six), 1 + six_nine(n - nine))
print((six_nine(x)))
| import bisect
x = int(eval(input()))
six_list = [6 ** i for i in range(7)]
nine_list = [9 ** i for i in range(6)]
def six_nine(n):
if n < 6:
return n
else:
six = six_list[bisect.bisect_right(six_list, n) - 1]
nine = nine_list[bisect.bisect_right(nine_list, n) - 1]
return min(n // six + six_nine(n % six), 1 + six_nine(n - nine))
print((six_nine(x)))
| 17 | 17 | 405 | 404 | import bisect
x = int(eval(input()))
six_list = [6**i for i in range(7)]
nine_list = [9**i for i in range(6)]
def six_nine(n):
if n == 0:
return 0
else:
six = six_list[bisect.bisect_right(six_list, n) - 1]
nine = nine_list[bisect.bisect_right(nine_list, n) - 1]
return min(n // six + six_nine(n % six), 1 + six_nine(n - nine))
print((six_nine(x)))
| import bisect
x = int(eval(input()))
six_list = [6**i for i in range(7)]
nine_list = [9**i for i in range(6)]
def six_nine(n):
if n < 6:
return n
else:
six = six_list[bisect.bisect_right(six_list, n) - 1]
nine = nine_list[bisect.bisect_right(nine_list, n) - 1]
return min(n // six + six_nine(n % six), 1 + six_nine(n - nine))
print((six_nine(x)))
| false | 0 | [
"- if n == 0:",
"- return 0",
"+ if n < 6:",
"+ return n"
] | false | 0.052537 | 0.049968 | 1.051417 | [
"s334859652",
"s839172487"
] |
u090649502 | p02820 | python | s725591353 | s873230762 | 56 | 49 | 4,212 | 4,084 | Accepted | Accepted | 12.5 | #!/usr/bin/env python3
import sys
def solve(N: int, K: int, R: int, S: int, P: int, T: str):
ans=0
flag=[False]*N
for i in range(N):
if i<K:
ans+=P if T[i]=='r' else S if T[i]=='p' else R
flag[i]=True
for i in range(K, N):
if T[i]!=T[i-K] or (not flag[i-K]):
ans+=P if T[i]=='r' else S if T[i]=='p' else R
flag[i]=True
print(ans)
return
# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
K = int(next(tokens)) # type: int
R = int(next(tokens)) # type: int
S = int(next(tokens)) # type: int
P = int(next(tokens)) # type: int
T = next(tokens) # type: str
solve(N, K, R, S, P, T)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
def solve(N: int, K: int, R: int, S: int, P: int, T: str):
ans=0
flag=[False]*N
for i in range(N):
if i<K or T[i]!=T[i-K] or (not flag[i-K]):
ans+=P if T[i]=='r' else S if T[i]=='p' else R
flag[i]=True
print(ans)
return
# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
K = int(next(tokens)) # type: int
R = int(next(tokens)) # type: int
S = int(next(tokens)) # type: int
P = int(next(tokens)) # type: int
T = next(tokens) # type: str
solve(N, K, R, S, P, T)
if __name__ == '__main__':
main()
| 38 | 34 | 1,102 | 979 | #!/usr/bin/env python3
import sys
def solve(N: int, K: int, R: int, S: int, P: int, T: str):
ans = 0
flag = [False] * N
for i in range(N):
if i < K:
ans += P if T[i] == "r" else S if T[i] == "p" else R
flag[i] = True
for i in range(K, N):
if T[i] != T[i - K] or (not flag[i - K]):
ans += P if T[i] == "r" else S if T[i] == "p" else R
flag[i] = True
print(ans)
return
# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
K = int(next(tokens)) # type: int
R = int(next(tokens)) # type: int
S = int(next(tokens)) # type: int
P = int(next(tokens)) # type: int
T = next(tokens) # type: str
solve(N, K, R, S, P, T)
if __name__ == "__main__":
main()
| #!/usr/bin/env python3
import sys
def solve(N: int, K: int, R: int, S: int, P: int, T: str):
ans = 0
flag = [False] * N
for i in range(N):
if i < K or T[i] != T[i - K] or (not flag[i - K]):
ans += P if T[i] == "r" else S if T[i] == "p" else R
flag[i] = True
print(ans)
return
# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
K = int(next(tokens)) # type: int
R = int(next(tokens)) # type: int
S = int(next(tokens)) # type: int
P = int(next(tokens)) # type: int
T = next(tokens) # type: str
solve(N, K, R, S, P, T)
if __name__ == "__main__":
main()
| false | 10.526316 | [
"- if i < K:",
"- ans += P if T[i] == \"r\" else S if T[i] == \"p\" else R",
"- flag[i] = True",
"- for i in range(K, N):",
"- if T[i] != T[i - K] or (not flag[i - K]):",
"+ if i < K or T[i] != T[i - K] or (not flag[i - K]):"
] | false | 0.007649 | 0.091669 | 0.083444 | [
"s725591353",
"s873230762"
] |
u045909335 | p03220 | python | s163954294 | s937758561 | 150 | 18 | 12,492 | 3,060 | Accepted | Accepted | 88 | import numpy as np
def main():
N = int(eval(input()))
T, A = list(map(int, input().split()))
H = list(map(int, input().split()))
for i in range(N):
H[i] = T- H[i] * 0.006
print((np.abs(np.asarray(H) - A).argmin()+1))
if __name__ == '__main__':
main() | def main():
N = int(eval(input()))
T, A = list(map(int, input().split()))
H = list(map(int, input().split()))
for i in range(N):
H[i] = abs(A - (T- H[i] * 0.006))
print((H.index(min(H))+1))
if __name__ == '__main__':
main() | 11 | 10 | 283 | 255 | import numpy as np
def main():
N = int(eval(input()))
T, A = list(map(int, input().split()))
H = list(map(int, input().split()))
for i in range(N):
H[i] = T - H[i] * 0.006
print((np.abs(np.asarray(H) - A).argmin() + 1))
if __name__ == "__main__":
main()
| def main():
N = int(eval(input()))
T, A = list(map(int, input().split()))
H = list(map(int, input().split()))
for i in range(N):
H[i] = abs(A - (T - H[i] * 0.006))
print((H.index(min(H)) + 1))
if __name__ == "__main__":
main()
| false | 9.090909 | [
"-import numpy as np",
"-",
"-",
"- H[i] = T - H[i] * 0.006",
"- print((np.abs(np.asarray(H) - A).argmin() + 1))",
"+ H[i] = abs(A - (T - H[i] * 0.006))",
"+ print((H.index(min(H)) + 1))"
] | false | 0.174059 | 0.054582 | 3.188937 | [
"s163954294",
"s937758561"
] |
u075304271 | p03086 | python | s455997209 | s545030381 | 152 | 121 | 12,500 | 77,372 | Accepted | Accepted | 20.39 | import math
import itertools
import numpy as np
def solve():
s = eval(input())
le = len(s)
ans = 0
for i in range(le):
for j in range(i, le):
if all("AGCT".count(k) == 1 for k in s[i:j+1]):
ans = max(ans, j-i+1)
print(ans)
return 0
if __name__ == "__main__":
solve()
| import math
import collections
import fractions
import itertools
import functools
import operator
def solve():
s = eval(input())
size = len(s)
ans = 0
for beg in range(size):
for end in range(beg+1, size+1):
if all('ACGT'.count(c) == 1 for c in s[beg:end]):
ans = max(ans, end-beg)
print(ans)
return 0
if __name__ == "__main__":
solve()
| 17 | 20 | 343 | 416 | import math
import itertools
import numpy as np
def solve():
s = eval(input())
le = len(s)
ans = 0
for i in range(le):
for j in range(i, le):
if all("AGCT".count(k) == 1 for k in s[i : j + 1]):
ans = max(ans, j - i + 1)
print(ans)
return 0
if __name__ == "__main__":
solve()
| import math
import collections
import fractions
import itertools
import functools
import operator
def solve():
s = eval(input())
size = len(s)
ans = 0
for beg in range(size):
for end in range(beg + 1, size + 1):
if all("ACGT".count(c) == 1 for c in s[beg:end]):
ans = max(ans, end - beg)
print(ans)
return 0
if __name__ == "__main__":
solve()
| false | 15 | [
"+import collections",
"+import fractions",
"-import numpy as np",
"+import functools",
"+import operator",
"- le = len(s)",
"+ size = len(s)",
"- for i in range(le):",
"- for j in range(i, le):",
"- if all(\"AGCT\".count(k) == 1 for k in s[i : j + 1]):",
"- ans = max(ans, j - i + 1)",
"+ for beg in range(size):",
"+ for end in range(beg + 1, size + 1):",
"+ if all(\"ACGT\".count(c) == 1 for c in s[beg:end]):",
"+ ans = max(ans, end - beg)"
] | false | 0.103124 | 0.037054 | 2.783048 | [
"s455997209",
"s545030381"
] |
u046187684 | p03503 | python | s152998980 | s282162126 | 71 | 65 | 3,188 | 3,188 | Accepted | Accepted | 8.45 | def solve(string):
n, *fp = string.split()
n = int(n)
f = fp[:10 * n]
p = list(map(int, fp[10 * n:]))
int_f = [int("".join(f[10 * i:10 * (i + 1)]), 2) for i in range(n)]
return str(
max(
sum([p[11 * i + bin(o & _f).count("1")]
for i, _f in enumerate(int_f)])
for o in range(1, 2**10)))
if __name__ == '__main__':
n = int(eval(input()))
print((solve('{}\n'.format(n) + '\n'.join([eval(input()) for _ in range(2 * n)]))))
| def solve(string):
n, *fp = list(map(int, string.split()))
f = "".join(map(str, fp[:10 * n]))
p = fp[10 * n:]
int_f = [int(f[10 * i:10 * (i + 1)], 2) for i in range(n)]
return str(
max(
sum([p[11 * i + bin(o & _f).count("1")]
for i, _f in enumerate(int_f)])
for o in range(1, 2**10)))
if __name__ == '__main__':
n = int(eval(input()))
print((solve('{}\n'.format(n) + '\n'.join([eval(input()) for _ in range(2 * n)]))))
| 16 | 15 | 504 | 492 | def solve(string):
n, *fp = string.split()
n = int(n)
f = fp[: 10 * n]
p = list(map(int, fp[10 * n :]))
int_f = [int("".join(f[10 * i : 10 * (i + 1)]), 2) for i in range(n)]
return str(
max(
sum([p[11 * i + bin(o & _f).count("1")] for i, _f in enumerate(int_f)])
for o in range(1, 2**10)
)
)
if __name__ == "__main__":
n = int(eval(input()))
print((solve("{}\n".format(n) + "\n".join([eval(input()) for _ in range(2 * n)]))))
| def solve(string):
n, *fp = list(map(int, string.split()))
f = "".join(map(str, fp[: 10 * n]))
p = fp[10 * n :]
int_f = [int(f[10 * i : 10 * (i + 1)], 2) for i in range(n)]
return str(
max(
sum([p[11 * i + bin(o & _f).count("1")] for i, _f in enumerate(int_f)])
for o in range(1, 2**10)
)
)
if __name__ == "__main__":
n = int(eval(input()))
print((solve("{}\n".format(n) + "\n".join([eval(input()) for _ in range(2 * n)]))))
| false | 6.25 | [
"- n, *fp = string.split()",
"- n = int(n)",
"- f = fp[: 10 * n]",
"- p = list(map(int, fp[10 * n :]))",
"- int_f = [int(\"\".join(f[10 * i : 10 * (i + 1)]), 2) for i in range(n)]",
"+ n, *fp = list(map(int, string.split()))",
"+ f = \"\".join(map(str, fp[: 10 * n]))",
"+ p = fp[10 * n :]",
"+ int_f = [int(f[10 * i : 10 * (i + 1)], 2) for i in range(n)]"
] | false | 0.086876 | 0.04078 | 2.130383 | [
"s152998980",
"s282162126"
] |
u753803401 | p03700 | python | s633675245 | s522856029 | 676 | 356 | 44,892 | 46,300 | Accepted | Accepted | 47.34 | import sys
def solve():
input = sys.stdin.readline
mod = 10 ** 9 + 7
n, a, b = list(map(int, input().rstrip('\n').split()))
h = [int(input().rstrip('\n')) for _ in range(n)]
cor_v = 10 ** 20
inc_v = -1
while cor_v - inc_v > 1:
bin_v = (cor_v + inc_v) // 2
cost = 0
#条件を満たすcostを全検索
for v in h:
if v > bin_v * b:
cost += (v - bin_v * b + (a - b) - 1) // (a - b)
#costが制約を満たすか
if cost <= bin_v:
cor_v = bin_v
else:
inc_v = bin_v
print(cor_v)
if __name__ == '__main__':
solve()
| import sys
def solve():
input = sys.stdin.readline
mod = 10 ** 9 + 7
n, a, b = list(map(int, input().rstrip('\n').split()))
h = [int(input().rstrip('\n')) for _ in range(n)]
cor_v = 10 ** 16
inc_v = -1
while cor_v - inc_v > 1:
bin_v = (cor_v + inc_v) // 2
cost = 0
#条件を満たすcostを全検索
for i in range(n):
hp = h[i] - bin_v * b
if hp > 0:
cost += (hp + (a - b) - 1) // (a - b)
#costが制約を満たすか
if cost <= bin_v:
cor_v = bin_v
else:
inc_v = bin_v
print(cor_v)
if __name__ == '__main__':
solve()
| 28 | 28 | 650 | 672 | import sys
def solve():
input = sys.stdin.readline
mod = 10**9 + 7
n, a, b = list(map(int, input().rstrip("\n").split()))
h = [int(input().rstrip("\n")) for _ in range(n)]
cor_v = 10**20
inc_v = -1
while cor_v - inc_v > 1:
bin_v = (cor_v + inc_v) // 2
cost = 0
# 条件を満たすcostを全検索
for v in h:
if v > bin_v * b:
cost += (v - bin_v * b + (a - b) - 1) // (a - b)
# costが制約を満たすか
if cost <= bin_v:
cor_v = bin_v
else:
inc_v = bin_v
print(cor_v)
if __name__ == "__main__":
solve()
| import sys
def solve():
input = sys.stdin.readline
mod = 10**9 + 7
n, a, b = list(map(int, input().rstrip("\n").split()))
h = [int(input().rstrip("\n")) for _ in range(n)]
cor_v = 10**16
inc_v = -1
while cor_v - inc_v > 1:
bin_v = (cor_v + inc_v) // 2
cost = 0
# 条件を満たすcostを全検索
for i in range(n):
hp = h[i] - bin_v * b
if hp > 0:
cost += (hp + (a - b) - 1) // (a - b)
# costが制約を満たすか
if cost <= bin_v:
cor_v = bin_v
else:
inc_v = bin_v
print(cor_v)
if __name__ == "__main__":
solve()
| false | 0 | [
"- cor_v = 10**20",
"+ cor_v = 10**16",
"- for v in h:",
"- if v > bin_v * b:",
"- cost += (v - bin_v * b + (a - b) - 1) // (a - b)",
"+ for i in range(n):",
"+ hp = h[i] - bin_v * b",
"+ if hp > 0:",
"+ cost += (hp + (a - b) - 1) // (a - b)"
] | false | 0.044364 | 0.108769 | 0.407871 | [
"s633675245",
"s522856029"
] |
u473433753 | p03013 | python | s291829655 | s627537356 | 450 | 366 | 463,712 | 465,836 | Accepted | Accepted | 18.67 | import math
def fib(q):
fibonacci = [0,1]
for i in range(2,q):
fibonacci.append(fibonacci[i-2]+fibonacci[i-1])
return fibonacci[q-1]
n,m = list(map(int, input("").split()))
a=[]
a.append(-1)
for i in range(m):
a.append(int(eval(input())))
a.append(n+1)
out=1
c=10**9+7
for i in range(m+1):
out*=int(fib(a[i+1]-a[i]))
out%=c
print(out) | import math
def fib(q):
fibonacci = [0,1]
for i in range(2,q):
fibonacci.append(fibonacci[i-2]+fibonacci[i-1])
return fibonacci[q-1]
n,m = list(map(int, input("").split()))
a=[]
a.append(-1)
for i in range(m):
a.append(int(eval(input())))
a.append(n+1)
out=1
c=10**9+7
for i in range(m+1):
out*=int(fib(a[i+1]-a[i]))
out%=c
print(out) | 18 | 18 | 372 | 376 | import math
def fib(q):
fibonacci = [0, 1]
for i in range(2, q):
fibonacci.append(fibonacci[i - 2] + fibonacci[i - 1])
return fibonacci[q - 1]
n, m = list(map(int, input("").split()))
a = []
a.append(-1)
for i in range(m):
a.append(int(eval(input())))
a.append(n + 1)
out = 1
c = 10**9 + 7
for i in range(m + 1):
out *= int(fib(a[i + 1] - a[i]))
out %= c
print(out)
| import math
def fib(q):
fibonacci = [0, 1]
for i in range(2, q):
fibonacci.append(fibonacci[i - 2] + fibonacci[i - 1])
return fibonacci[q - 1]
n, m = list(map(int, input("").split()))
a = []
a.append(-1)
for i in range(m):
a.append(int(eval(input())))
a.append(n + 1)
out = 1
c = 10**9 + 7
for i in range(m + 1):
out *= int(fib(a[i + 1] - a[i]))
out %= c
print(out)
| false | 0 | [
"-out %= c",
"+ out %= c"
] | false | 0.037305 | 0.036524 | 1.021398 | [
"s291829655",
"s627537356"
] |
u588341295 | p02747 | python | s277857197 | s921866653 | 122 | 19 | 3,444 | 3,188 | Accepted | Accepted | 84.43 | # -*- coding: utf-8 -*-
import sys
from collections import Counter
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
S = eval(input())
N = len(S)
if N % 2 == 1:
No()
exit()
for i in range(0, N, 2):
if S[i] != 'h' or S[i+1] != 'i':
No()
exit()
Yes()
| # -*- coding: utf-8 -*-
import sys
import re
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
S = eval(input())
N = len(S)
if re.match(r'^(hi)+$', S):
Yes()
else:
No()
| 33 | 28 | 897 | 791 | # -*- coding: utf-8 -*-
import sys
from collections import Counter
def input():
return sys.stdin.readline().strip()
def list2d(a, b, c):
return [[c] * b for i in range(a)]
def list3d(a, b, c, d):
return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e):
return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1):
return int(-(-x // y))
def INT():
return int(eval(input()))
def MAP():
return list(map(int, input().split()))
def LIST(N=None):
return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes():
print("Yes")
def No():
print("No")
def YES():
print("YES")
def NO():
print("NO")
sys.setrecursionlimit(10**9)
INF = 10**18
MOD = 10**9 + 7
S = eval(input())
N = len(S)
if N % 2 == 1:
No()
exit()
for i in range(0, N, 2):
if S[i] != "h" or S[i + 1] != "i":
No()
exit()
Yes()
| # -*- coding: utf-8 -*-
import sys
import re
def input():
return sys.stdin.readline().strip()
def list2d(a, b, c):
return [[c] * b for i in range(a)]
def list3d(a, b, c, d):
return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e):
return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1):
return int(-(-x // y))
def INT():
return int(eval(input()))
def MAP():
return list(map(int, input().split()))
def LIST(N=None):
return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes():
print("Yes")
def No():
print("No")
def YES():
print("YES")
def NO():
print("NO")
sys.setrecursionlimit(10**9)
INF = 10**18
MOD = 10**9 + 7
S = eval(input())
N = len(S)
if re.match(r"^(hi)+$", S):
Yes()
else:
No()
| false | 15.151515 | [
"-from collections import Counter",
"+import re",
"-if N % 2 == 1:",
"+if re.match(r\"^(hi)+$\", S):",
"+ Yes()",
"+else:",
"- exit()",
"-for i in range(0, N, 2):",
"- if S[i] != \"h\" or S[i + 1] != \"i\":",
"- No()",
"- exit()",
"-Yes()"
] | false | 0.036406 | 0.095877 | 0.379718 | [
"s277857197",
"s921866653"
] |
u744920373 | p02936 | python | s333966540 | s198365608 | 1,791 | 1,563 | 313,852 | 89,008 | Accepted | Accepted | 12.73 | import sys
sys.setrecursionlimit(10**8)
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 li2(N): return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
def dp2(ini, i, j): return [[ini]*i for i2 in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for i2 in range(j)] for i3 in range(k)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
## DFS
def main():
#入力受け取り
N, Q = mi()
x = li2(N-1)
cnt = [0]*N
for i in range(Q):
p0, p1 = mi()
cnt[p0-1] += p1
#隣接リスト作成
adj = [[] for i in range(N)]
for i in range(N-1):
#x[i][0] -= 1
#x[i][1] -= 1
adj[x[i][0]-1].append(x[i][1]-1)
adj[x[i][1]-1].append(x[i][0]-1)
#DFS
global ans
ans = [0]*N
def dfs(fr, nx):
ans[nx] += ans[fr] + cnt[nx]
for v in adj[nx]:
if v != fr:
dfs(nx, v)
dfs(0, 0)
'''
for i in range(N):
print(ans[i], '', end='')
'''
print((*ans))
if __name__ == "__main__":
main() | import sys
def ii(): return int(sys.stdin.readline())
def mi(): return map(int, sys.stdin.readline().split())
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
def dp2(ini, i, j): return [[ini]*i for i2 in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for i2 in range(j)] for i3 in range(k)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
## BFS
from collections import deque
def main():
#入力受け取り
N, Q = mi()
x = li2(N-1)
cnt = [0]*N
for i in range(Q):
p0, p1 = mi()
cnt[p0-1] += p1
#隣接リスト作成
adj = [[] for i in range(N)]
for i in range(N-1):
x[i][0] -= 1
x[i][1] -= 1
adj[x[i][0]].append(x[i][1])
adj[x[i][1]].append(x[i][0])
que = deque()
ans = [0]*N
# BFS
que.append((0, 0))
num = 0
while que!=deque():
v = que.popleft()
ans[v[1]] = ans[v[0]] + cnt[v[1]]
for next in adj[v[1]]:
if next != v[0]:
que.append((v[1], next))
for k in ans:
print(k, '', end='')
if __name__ == "__main__":
main()
| 51 | 50 | 1,257 | 1,288 | import sys
sys.setrecursionlimit(10**8)
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 li2(N):
return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
def dp2(ini, i, j):
return [[ini] * i for i2 in range(j)]
def dp3(ini, i, j, k):
return [[[ini] * i for i2 in range(j)] for i3 in range(k)]
# import bisect #bisect.bisect_left(B, a)
# from collections import defaultdict #d = defaultdict(int) d[key] += value
## DFS
def main():
# 入力受け取り
N, Q = mi()
x = li2(N - 1)
cnt = [0] * N
for i in range(Q):
p0, p1 = mi()
cnt[p0 - 1] += p1
# 隣接リスト作成
adj = [[] for i in range(N)]
for i in range(N - 1):
# x[i][0] -= 1
# x[i][1] -= 1
adj[x[i][0] - 1].append(x[i][1] - 1)
adj[x[i][1] - 1].append(x[i][0] - 1)
# DFS
global ans
ans = [0] * N
def dfs(fr, nx):
ans[nx] += ans[fr] + cnt[nx]
for v in adj[nx]:
if v != fr:
dfs(nx, v)
dfs(0, 0)
"""
for i in range(N):
print(ans[i], '', end='')
"""
print((*ans))
if __name__ == "__main__":
main()
| import sys
def ii():
return int(sys.stdin.readline())
def mi():
return map(int, sys.stdin.readline().split())
def li():
return list(map(int, sys.stdin.readline().split()))
def li2(N):
return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
def dp2(ini, i, j):
return [[ini] * i for i2 in range(j)]
def dp3(ini, i, j, k):
return [[[ini] * i for i2 in range(j)] for i3 in range(k)]
# import bisect #bisect.bisect_left(B, a)
# from collections import defaultdict #d = defaultdict(int) d[key] += value
## BFS
from collections import deque
def main():
# 入力受け取り
N, Q = mi()
x = li2(N - 1)
cnt = [0] * N
for i in range(Q):
p0, p1 = mi()
cnt[p0 - 1] += p1
# 隣接リスト作成
adj = [[] for i in range(N)]
for i in range(N - 1):
x[i][0] -= 1
x[i][1] -= 1
adj[x[i][0]].append(x[i][1])
adj[x[i][1]].append(x[i][0])
que = deque()
ans = [0] * N
# BFS
que.append((0, 0))
num = 0
while que != deque():
v = que.popleft()
ans[v[1]] = ans[v[0]] + cnt[v[1]]
for next in adj[v[1]]:
if next != v[0]:
que.append((v[1], next))
for k in ans:
print(k, "", end="")
if __name__ == "__main__":
main()
| false | 1.960784 | [
"-",
"-sys.setrecursionlimit(10**8)",
"- return list(map(int, sys.stdin.readline().split()))",
"+ return map(int, sys.stdin.readline().split())",
"-## DFS",
"+## BFS",
"+from collections import deque",
"+",
"+",
"- # x[i][0] -= 1",
"- # x[i][1] -= 1",
"- adj[x[i][0] - 1].append(x[i][1] - 1)",
"- adj[x[i][1] - 1].append(x[i][0] - 1)",
"- # DFS",
"- global ans",
"+ x[i][0] -= 1",
"+ x[i][1] -= 1",
"+ adj[x[i][0]].append(x[i][1])",
"+ adj[x[i][1]].append(x[i][0])",
"+ que = deque()",
"-",
"- def dfs(fr, nx):",
"- ans[nx] += ans[fr] + cnt[nx]",
"- for v in adj[nx]:",
"- if v != fr:",
"- dfs(nx, v)",
"-",
"- dfs(0, 0)",
"- \"\"\"",
"- for i in range(N):",
"- print(ans[i], '', end='')",
"- \"\"\"",
"- print((*ans))",
"+ # BFS",
"+ que.append((0, 0))",
"+ num = 0",
"+ while que != deque():",
"+ v = que.popleft()",
"+ ans[v[1]] = ans[v[0]] + cnt[v[1]]",
"+ for next in adj[v[1]]:",
"+ if next != v[0]:",
"+ que.append((v[1], next))",
"+ for k in ans:",
"+ print(k, \"\", end=\"\")"
] | false | 0.10751 | 0.060872 | 1.766158 | [
"s333966540",
"s198365608"
] |
u451012573 | p03031 | python | s087952159 | s640294339 | 194 | 25 | 40,336 | 3,064 | Accepted | Accepted | 87.11 | def main():
N, M = list(map(int, input().split()))
S = []
for i in range(M):
S.append(list([int(x) - 1 for x in input().split()])[1:])
P = list(map(int, input().split()))
ans = 0
for bit in range(1 << N):
for i in range(M):
on = 0
for j in S[i]:
if bit & (1 << j):
on += 1
if on % 2 != P[i]:
break
else:
ans += 1
print(ans)
if __name__ == '__main__':
main()
| def main():
N, M = list(map(int, input().split()))
S = [list([int(x) - 1 for x in input().split()])[1:] for _ in range(M)]
P = list(map(int, input().split()))
ans = 0
for bit in range(1 << N):
for i in range(M):
on = 0
for j in S[i]:
if bit & (1 << j):
on += 1
if on % 2 != P[i]:
break
else:
ans += 1
print(ans)
if __name__ == '__main__':
main()
| 23 | 21 | 538 | 512 | def main():
N, M = list(map(int, input().split()))
S = []
for i in range(M):
S.append(list([int(x) - 1 for x in input().split()])[1:])
P = list(map(int, input().split()))
ans = 0
for bit in range(1 << N):
for i in range(M):
on = 0
for j in S[i]:
if bit & (1 << j):
on += 1
if on % 2 != P[i]:
break
else:
ans += 1
print(ans)
if __name__ == "__main__":
main()
| def main():
N, M = list(map(int, input().split()))
S = [list([int(x) - 1 for x in input().split()])[1:] for _ in range(M)]
P = list(map(int, input().split()))
ans = 0
for bit in range(1 << N):
for i in range(M):
on = 0
for j in S[i]:
if bit & (1 << j):
on += 1
if on % 2 != P[i]:
break
else:
ans += 1
print(ans)
if __name__ == "__main__":
main()
| false | 8.695652 | [
"- S = []",
"- for i in range(M):",
"- S.append(list([int(x) - 1 for x in input().split()])[1:])",
"+ S = [list([int(x) - 1 for x in input().split()])[1:] for _ in range(M)]"
] | false | 0.075972 | 0.037283 | 2.0377 | [
"s087952159",
"s640294339"
] |
u849029577 | p03835 | python | s801606234 | s156200827 | 452 | 261 | 120,392 | 40,684 | Accepted | Accepted | 42.26 | k, s = list(map(int, input().split()))
ans = []
for x in range(k+1):
for y in range(k+1):
z = s-(x+y)
if 0 <= z <= k:
ans.append(0)
print((len(ans))) | k, s = list(map(int, input().split()))
count = 0
for x in range(k+1):
for y in range(k+1):
z = s-(x+y)
if 0 <= z <= k:
count += 1
print(count) | 8 | 8 | 180 | 175 | k, s = list(map(int, input().split()))
ans = []
for x in range(k + 1):
for y in range(k + 1):
z = s - (x + y)
if 0 <= z <= k:
ans.append(0)
print((len(ans)))
| k, s = list(map(int, input().split()))
count = 0
for x in range(k + 1):
for y in range(k + 1):
z = s - (x + y)
if 0 <= z <= k:
count += 1
print(count)
| false | 0 | [
"-ans = []",
"+count = 0",
"- ans.append(0)",
"-print((len(ans)))",
"+ count += 1",
"+print(count)"
] | false | 0.077873 | 0.060561 | 1.285858 | [
"s801606234",
"s156200827"
] |
u014268998 | p03031 | python | s810142631 | s369685085 | 44 | 35 | 3,064 | 3,064 | Accepted | Accepted | 20.45 |
n,m = list(map(int,input().split()))
a = [list(map(int,input().split())) for i in range(m)]
target = list(map(int,input().split()))
#n,m = 2,3
#a = [[2,1,2], [1,1],[1,2]]
#target = [0,0,1]
ans = 0
s = [0] * n
for i in range(2**n):
x = format(i,'b').zfill(n)
for num,j in enumerate(x):
s[num] = int(j)
ck = 1
for num,alist in enumerate(a):
count = 0
for j in range(1,alist[0]+1):
count += s[alist[j]-1]
if(count%2 != target[num]):
ck = 0
ans += ck
print(ans) | # n個のスイッチ
# m個の電球
n,m = list(map(int,input().split()))
a = [list(map(int,input().split())) for _ in range(m)]
p = list(map(int,input().split()))
#n,m = 2,2
#a = [[2,1,2],[1,2]]
#p = [0,1]
#n,m = 10,10
#a = [[4, 6, 3, 7, 5], [3, 1, 10, 5], [4, 8, 7, 1, 2], [5, 5, 10, 2, 7, 8], [6, 3, 1, 6, 8, 2, 5], [5, 6, 10, 7, 1, 3], [4, 3, 5, 7, 6], [4, 3, 9, 7, 5], [4, 3, 6, 5, 7], [4, 2, 7, 1, 8]]
#p = [0, 0, 1, 1, 1, 0, 0, 0, 0, 1]
ans = 0
for i in range(0,2**n): #スイッチの組み合わせを生成
ck = True
for j in range(0,m): #j番目の電球が付くかを確認
# a[j][0]つながっているスイッチの数
count = 0
for k in range(0,a[j][0]):
#print(a[j][k+1]) 番目のスイッチをチェック
count += i>>(a[j][k+1]-1) & 1
if count%2 != p[j]:
ck = False
break
if ck:
ans += 1
print(ans)
| 27 | 32 | 521 | 784 | n, m = list(map(int, input().split()))
a = [list(map(int, input().split())) for i in range(m)]
target = list(map(int, input().split()))
# n,m = 2,3
# a = [[2,1,2], [1,1],[1,2]]
# target = [0,0,1]
ans = 0
s = [0] * n
for i in range(2**n):
x = format(i, "b").zfill(n)
for num, j in enumerate(x):
s[num] = int(j)
ck = 1
for num, alist in enumerate(a):
count = 0
for j in range(1, alist[0] + 1):
count += s[alist[j] - 1]
if count % 2 != target[num]:
ck = 0
ans += ck
print(ans)
| # n個のスイッチ
# m個の電球
n, m = list(map(int, input().split()))
a = [list(map(int, input().split())) for _ in range(m)]
p = list(map(int, input().split()))
# n,m = 2,2
# a = [[2,1,2],[1,2]]
# p = [0,1]
# n,m = 10,10
# a = [[4, 6, 3, 7, 5], [3, 1, 10, 5], [4, 8, 7, 1, 2], [5, 5, 10, 2, 7, 8], [6, 3, 1, 6, 8, 2, 5], [5, 6, 10, 7, 1, 3], [4, 3, 5, 7, 6], [4, 3, 9, 7, 5], [4, 3, 6, 5, 7], [4, 2, 7, 1, 8]]
# p = [0, 0, 1, 1, 1, 0, 0, 0, 0, 1]
ans = 0
for i in range(0, 2**n): # スイッチの組み合わせを生成
ck = True
for j in range(0, m): # j番目の電球が付くかを確認
# a[j][0]つながっているスイッチの数
count = 0
for k in range(0, a[j][0]):
# print(a[j][k+1]) 番目のスイッチをチェック
count += i >> (a[j][k + 1] - 1) & 1
if count % 2 != p[j]:
ck = False
break
if ck:
ans += 1
print(ans)
| false | 15.625 | [
"+# n個のスイッチ",
"+# m個の電球",
"-a = [list(map(int, input().split())) for i in range(m)]",
"-target = list(map(int, input().split()))",
"-# n,m = 2,3",
"-# a = [[2,1,2], [1,1],[1,2]]",
"-# target = [0,0,1]",
"+a = [list(map(int, input().split())) for _ in range(m)]",
"+p = list(map(int, input().split()))",
"+# n,m = 2,2",
"+# a = [[2,1,2],[1,2]]",
"+# p = [0,1]",
"+# n,m = 10,10",
"+# a = [[4, 6, 3, 7, 5], [3, 1, 10, 5], [4, 8, 7, 1, 2], [5, 5, 10, 2, 7, 8], [6, 3, 1, 6, 8, 2, 5], [5, 6, 10, 7, 1, 3], [4, 3, 5, 7, 6], [4, 3, 9, 7, 5], [4, 3, 6, 5, 7], [4, 2, 7, 1, 8]]",
"+# p = [0, 0, 1, 1, 1, 0, 0, 0, 0, 1]",
"-s = [0] * n",
"-for i in range(2**n):",
"- x = format(i, \"b\").zfill(n)",
"- for num, j in enumerate(x):",
"- s[num] = int(j)",
"- ck = 1",
"- for num, alist in enumerate(a):",
"+for i in range(0, 2**n): # スイッチの組み合わせを生成",
"+ ck = True",
"+ for j in range(0, m): # j番目の電球が付くかを確認",
"+ # a[j][0]つながっているスイッチの数",
"- for j in range(1, alist[0] + 1):",
"- count += s[alist[j] - 1]",
"- if count % 2 != target[num]:",
"- ck = 0",
"- ans += ck",
"+ for k in range(0, a[j][0]):",
"+ # print(a[j][k+1]) 番目のスイッチをチェック",
"+ count += i >> (a[j][k + 1] - 1) & 1",
"+ if count % 2 != p[j]:",
"+ ck = False",
"+ break",
"+ if ck:",
"+ ans += 1"
] | false | 0.125601 | 0.042395 | 2.962666 | [
"s810142631",
"s369685085"
] |
u509739538 | p02678 | python | s969002408 | s629496477 | 831 | 596 | 35,128 | 34,796 | Accepted | Accepted | 28.28 | import queue
n,m = list(map(int, input().split()))
puted = [1]*(n+1)
ab = [[] for i in range(n+1)]
for i in range(m):
a,b = list(map(int, input().split()))
ab[a].append(b)
ab[b].append(a)
q = queue.Queue()
flg = [-1]*n
flg[0] = 0
q.put(1)
while not q.empty():
item = q.get()
for i in ab[item]:
if puted[i]:
flg[i-1]=item
q.put(i)
puted[i]=0
if -1 in flg:
print("No")
exit()
print("Yes")
for i in range(1,len(flg)):
print((flg[i]))
| from collections import deque
n,m = list(map(int, input().split()))
puted = [1]*(n+1)
ab = [[] for i in range(n+1)]
for i in range(m):
a,b = list(map(int, input().split()))
ab[a].append(b)
ab[b].append(a)
q = deque([1])
flg = [-1]*n
flg[0] = 0
while q:
item = q.popleft()
for i in ab[item]:
if puted[i]:
flg[i-1]=item
q.append(i)
puted[i]=0
if -1 in flg:
print("No")
exit()
print("Yes")
for i in range(1,len(flg)):
print((flg[i]))
| 31 | 30 | 478 | 477 | import queue
n, m = list(map(int, input().split()))
puted = [1] * (n + 1)
ab = [[] for i in range(n + 1)]
for i in range(m):
a, b = list(map(int, input().split()))
ab[a].append(b)
ab[b].append(a)
q = queue.Queue()
flg = [-1] * n
flg[0] = 0
q.put(1)
while not q.empty():
item = q.get()
for i in ab[item]:
if puted[i]:
flg[i - 1] = item
q.put(i)
puted[i] = 0
if -1 in flg:
print("No")
exit()
print("Yes")
for i in range(1, len(flg)):
print((flg[i]))
| from collections import deque
n, m = list(map(int, input().split()))
puted = [1] * (n + 1)
ab = [[] for i in range(n + 1)]
for i in range(m):
a, b = list(map(int, input().split()))
ab[a].append(b)
ab[b].append(a)
q = deque([1])
flg = [-1] * n
flg[0] = 0
while q:
item = q.popleft()
for i in ab[item]:
if puted[i]:
flg[i - 1] = item
q.append(i)
puted[i] = 0
if -1 in flg:
print("No")
exit()
print("Yes")
for i in range(1, len(flg)):
print((flg[i]))
| false | 3.225806 | [
"-import queue",
"+from collections import deque",
"-q = queue.Queue()",
"+q = deque([1])",
"-q.put(1)",
"-while not q.empty():",
"- item = q.get()",
"+while q:",
"+ item = q.popleft()",
"- q.put(i)",
"+ q.append(i)"
] | false | 0.108662 | 0.096968 | 1.120593 | [
"s969002408",
"s629496477"
] |
u494058663 | p02983 | python | s020690943 | s594622159 | 748 | 538 | 3,064 | 9,176 | Accepted | Accepted | 28.07 | import sys
L,R = list(map(int,input().split()))
mod = 2019
cnt = 0
ans = float('inf')
List = [False for i in range(2019)]
for i in range(L,R):
for j in range(i+1,R+1):
tmp = (i*j)%mod
List[tmp] = True
ans = min(tmp,L*R,ans)
if cnt>=10**6 or all(List)==True:
print(ans)
sys.exit()
cnt +=1
print(ans) | def main():
mod = 2019
l,r = list(map(int,input().split()))
ans = 10**9
for i in range(l,min(l+2020,r+1)):
for j in range(i+1,min(l+2020,r+1)):
ans = min(ans,(i*j)%mod)
print(ans)
main() | 16 | 9 | 375 | 228 | import sys
L, R = list(map(int, input().split()))
mod = 2019
cnt = 0
ans = float("inf")
List = [False for i in range(2019)]
for i in range(L, R):
for j in range(i + 1, R + 1):
tmp = (i * j) % mod
List[tmp] = True
ans = min(tmp, L * R, ans)
if cnt >= 10**6 or all(List) == True:
print(ans)
sys.exit()
cnt += 1
print(ans)
| def main():
mod = 2019
l, r = list(map(int, input().split()))
ans = 10**9
for i in range(l, min(l + 2020, r + 1)):
for j in range(i + 1, min(l + 2020, r + 1)):
ans = min(ans, (i * j) % mod)
print(ans)
main()
| false | 43.75 | [
"-import sys",
"+def main():",
"+ mod = 2019",
"+ l, r = list(map(int, input().split()))",
"+ ans = 10**9",
"+ for i in range(l, min(l + 2020, r + 1)):",
"+ for j in range(i + 1, min(l + 2020, r + 1)):",
"+ ans = min(ans, (i * j) % mod)",
"+ print(ans)",
"-L, R = list(map(int, input().split()))",
"-mod = 2019",
"-cnt = 0",
"-ans = float(\"inf\")",
"-List = [False for i in range(2019)]",
"-for i in range(L, R):",
"- for j in range(i + 1, R + 1):",
"- tmp = (i * j) % mod",
"- List[tmp] = True",
"- ans = min(tmp, L * R, ans)",
"- if cnt >= 10**6 or all(List) == True:",
"- print(ans)",
"- sys.exit()",
"- cnt += 1",
"-print(ans)",
"+",
"+main()"
] | false | 0.040535 | 0.177052 | 0.228947 | [
"s020690943",
"s594622159"
] |
u562935282 | p03039 | python | s518768180 | s089281414 | 205 | 185 | 11,384 | 54,128 | Accepted | Accepted | 9.76 | from collections import defaultdict
mod = 10 ** 9 + 7
memo = defaultdict(int)
def cmb(n, r):
if (n, r) in memo:
return memo[(n, r)]
if n < r or r < 0:
return 0
if r > n - r:
return cmb(n, n - r)
res = f[n] * pow(f[n - r], mod - 2, mod) * pow(f[r], mod - 2, mod) % mod
memo[(n, r)] = res
return res
n, m, k = list(map(int, input().split()))
f = [1]
for i in range(1, 2 * 10 ** 5 + 1):
f.append(f[-1] * i % mod)
ans = 0
for d in range(1, m):
ans += d * (m - d) * n ** 2
ans %= mod
for d in range(1, n):
ans += d * (n - d) * m ** 2
ans %= mod
ans *= cmb(n * m - 2, k - 2)
ans %= mod
print(ans)
| def solve():
mod = 10 ** 9 + 7
def cmb(n, r):
def build():
fs = [1]
t = 1
for x in range(1, h * w):
t = (t * x) % mod
fs.append(t)
invs = [1] * (h * w)
t = pow(t, mod - 2, mod)
invs[-1] = t
for x in range(h * w - 2, 0, -1):
t = (t * (x + 1)) % mod
invs[x] = t
return fs, invs
if r < 0 or r > n:
return 0
if r > (n - r):
return cmb(n, n - r)
if r == 0:
return 1
if r == 1:
return n
fs, invs = build()
return fs[n] * invs[n - r] * invs[r] % mod
h, w, k = list(map(int, input().split()))
c = cmb(h * w - 2, k - 2)
ret = (pow(w, 2) * sum((h - d) * d for d in range(h))
+ pow(h, 2) * sum((w - d) * d for d in range(w))) * c % mod
return ret
print((solve())) | 41 | 40 | 707 | 990 | from collections import defaultdict
mod = 10**9 + 7
memo = defaultdict(int)
def cmb(n, r):
if (n, r) in memo:
return memo[(n, r)]
if n < r or r < 0:
return 0
if r > n - r:
return cmb(n, n - r)
res = f[n] * pow(f[n - r], mod - 2, mod) * pow(f[r], mod - 2, mod) % mod
memo[(n, r)] = res
return res
n, m, k = list(map(int, input().split()))
f = [1]
for i in range(1, 2 * 10**5 + 1):
f.append(f[-1] * i % mod)
ans = 0
for d in range(1, m):
ans += d * (m - d) * n**2
ans %= mod
for d in range(1, n):
ans += d * (n - d) * m**2
ans %= mod
ans *= cmb(n * m - 2, k - 2)
ans %= mod
print(ans)
| def solve():
mod = 10**9 + 7
def cmb(n, r):
def build():
fs = [1]
t = 1
for x in range(1, h * w):
t = (t * x) % mod
fs.append(t)
invs = [1] * (h * w)
t = pow(t, mod - 2, mod)
invs[-1] = t
for x in range(h * w - 2, 0, -1):
t = (t * (x + 1)) % mod
invs[x] = t
return fs, invs
if r < 0 or r > n:
return 0
if r > (n - r):
return cmb(n, n - r)
if r == 0:
return 1
if r == 1:
return n
fs, invs = build()
return fs[n] * invs[n - r] * invs[r] % mod
h, w, k = list(map(int, input().split()))
c = cmb(h * w - 2, k - 2)
ret = (
(
pow(w, 2) * sum((h - d) * d for d in range(h))
+ pow(h, 2) * sum((w - d) * d for d in range(w))
)
* c
% mod
)
return ret
print((solve()))
| false | 2.439024 | [
"-from collections import defaultdict",
"+def solve():",
"+ mod = 10**9 + 7",
"-mod = 10**9 + 7",
"-memo = defaultdict(int)",
"+ def cmb(n, r):",
"+ def build():",
"+ fs = [1]",
"+ t = 1",
"+ for x in range(1, h * w):",
"+ t = (t * x) % mod",
"+ fs.append(t)",
"+ invs = [1] * (h * w)",
"+ t = pow(t, mod - 2, mod)",
"+ invs[-1] = t",
"+ for x in range(h * w - 2, 0, -1):",
"+ t = (t * (x + 1)) % mod",
"+ invs[x] = t",
"+ return fs, invs",
"+",
"+ if r < 0 or r > n:",
"+ return 0",
"+ if r > (n - r):",
"+ return cmb(n, n - r)",
"+ if r == 0:",
"+ return 1",
"+ if r == 1:",
"+ return n",
"+ fs, invs = build()",
"+ return fs[n] * invs[n - r] * invs[r] % mod",
"+",
"+ h, w, k = list(map(int, input().split()))",
"+ c = cmb(h * w - 2, k - 2)",
"+ ret = (",
"+ (",
"+ pow(w, 2) * sum((h - d) * d for d in range(h))",
"+ + pow(h, 2) * sum((w - d) * d for d in range(w))",
"+ )",
"+ * c",
"+ % mod",
"+ )",
"+ return ret",
"-def cmb(n, r):",
"- if (n, r) in memo:",
"- return memo[(n, r)]",
"- if n < r or r < 0:",
"- return 0",
"- if r > n - r:",
"- return cmb(n, n - r)",
"- res = f[n] * pow(f[n - r], mod - 2, mod) * pow(f[r], mod - 2, mod) % mod",
"- memo[(n, r)] = res",
"- return res",
"-",
"-",
"-n, m, k = list(map(int, input().split()))",
"-f = [1]",
"-for i in range(1, 2 * 10**5 + 1):",
"- f.append(f[-1] * i % mod)",
"-ans = 0",
"-for d in range(1, m):",
"- ans += d * (m - d) * n**2",
"- ans %= mod",
"-for d in range(1, n):",
"- ans += d * (n - d) * m**2",
"- ans %= mod",
"-ans *= cmb(n * m - 2, k - 2)",
"-ans %= mod",
"-print(ans)",
"+print((solve()))"
] | false | 0.146628 | 0.128957 | 1.137033 | [
"s518768180",
"s089281414"
] |
u189023301 | p02984 | python | s127370694 | s940782390 | 201 | 123 | 18,496 | 14,124 | Accepted | Accepted | 38.81 | import sys
input = sys.stdin.readline
n = int(eval(input()))
lis = list(map(int, input().split()))
res = sum(lis)
su = [0] * n
for i in range(n):
if i < 2:
su[i] = lis[i]
else:
su[i] = su[i-2] + lis[i]
ans = []
ans_a = ans.append
for i in range(n):
if i == 0:
b = su[-2]
ans_a(res-2*b)
elif i == 1:
b = su[-1] - su[i-1]
ans_a(res-2*b)
elif i == n:
b = su[-1] - lis[-1]
ans_a(res-2*b)
elif i % 2 == 0:
b = su[-2] - su[i-1] + su[i-2]
ans_a(res-2*b)
else:
b = su[-1] - su[i-1] + su[i-2]
ans_a(res-2*b)
print((*ans))
| import sys
input = sys.stdin.readline
n = int(eval(input()))
lis = list(map(int, input().split()))
su1 = sum(lis)
su2 = sum(lis[1::2])
ans = [0] * n
ans[0] = su1 - 2 * su2
for i in range(1, n):
ans[i] = 2 * lis[i - 1] - ans[i - 1]
print((*ans))
| 34 | 16 | 666 | 261 | import sys
input = sys.stdin.readline
n = int(eval(input()))
lis = list(map(int, input().split()))
res = sum(lis)
su = [0] * n
for i in range(n):
if i < 2:
su[i] = lis[i]
else:
su[i] = su[i - 2] + lis[i]
ans = []
ans_a = ans.append
for i in range(n):
if i == 0:
b = su[-2]
ans_a(res - 2 * b)
elif i == 1:
b = su[-1] - su[i - 1]
ans_a(res - 2 * b)
elif i == n:
b = su[-1] - lis[-1]
ans_a(res - 2 * b)
elif i % 2 == 0:
b = su[-2] - su[i - 1] + su[i - 2]
ans_a(res - 2 * b)
else:
b = su[-1] - su[i - 1] + su[i - 2]
ans_a(res - 2 * b)
print((*ans))
| import sys
input = sys.stdin.readline
n = int(eval(input()))
lis = list(map(int, input().split()))
su1 = sum(lis)
su2 = sum(lis[1::2])
ans = [0] * n
ans[0] = su1 - 2 * su2
for i in range(1, n):
ans[i] = 2 * lis[i - 1] - ans[i - 1]
print((*ans))
| false | 52.941176 | [
"-res = sum(lis)",
"-su = [0] * n",
"-for i in range(n):",
"- if i < 2:",
"- su[i] = lis[i]",
"- else:",
"- su[i] = su[i - 2] + lis[i]",
"-ans = []",
"-ans_a = ans.append",
"-for i in range(n):",
"- if i == 0:",
"- b = su[-2]",
"- ans_a(res - 2 * b)",
"- elif i == 1:",
"- b = su[-1] - su[i - 1]",
"- ans_a(res - 2 * b)",
"- elif i == n:",
"- b = su[-1] - lis[-1]",
"- ans_a(res - 2 * b)",
"- elif i % 2 == 0:",
"- b = su[-2] - su[i - 1] + su[i - 2]",
"- ans_a(res - 2 * b)",
"- else:",
"- b = su[-1] - su[i - 1] + su[i - 2]",
"- ans_a(res - 2 * b)",
"+su1 = sum(lis)",
"+su2 = sum(lis[1::2])",
"+ans = [0] * n",
"+ans[0] = su1 - 2 * su2",
"+for i in range(1, n):",
"+ ans[i] = 2 * lis[i - 1] - ans[i - 1]"
] | false | 0.036107 | 0.037365 | 0.966344 | [
"s127370694",
"s940782390"
] |
u562935282 | p03355 | python | s849975387 | s983615215 | 35 | 30 | 4,592 | 4,464 | Accepted | Accepted | 14.29 | # 解説
s = eval(input())
k = int(eval(input()))
st = set()
for start in range(len(s)):
for len_ in range(1, k + 1):
st.add(s[start:start + len_])
*a, = sorted(st)
print((a[k - 1]))
# 高々k文字
# kが小さいので
# 全列挙してソート
| def main():
S = eval(input())
N = len(S)
K = int(eval(input()))
tank = set()
for k in range(1, K + 1):
for i in range(N - k + 1):
t = S[i:i + k]
tank.add(t)
ans = sorted(tank)[K - 1]
print(ans)
if __name__ == '__main__':
main()
# import sys
# input = sys.stdin.readline
#
# sys.setrecursionlimit(10 ** 7)
#
# (int(x)-1 for x in input().split())
# rstrip()
#
# def binary_search(*, ok, ng, func):
# while abs(ok - ng) > 1:
# mid = (ok + ng) // 2
# if func(mid):
# ok = mid
# else:
# ng = mid
# return ok
| 15 | 34 | 223 | 651 | # 解説
s = eval(input())
k = int(eval(input()))
st = set()
for start in range(len(s)):
for len_ in range(1, k + 1):
st.add(s[start : start + len_])
(*a,) = sorted(st)
print((a[k - 1]))
# 高々k文字
# kが小さいので
# 全列挙してソート
| def main():
S = eval(input())
N = len(S)
K = int(eval(input()))
tank = set()
for k in range(1, K + 1):
for i in range(N - k + 1):
t = S[i : i + k]
tank.add(t)
ans = sorted(tank)[K - 1]
print(ans)
if __name__ == "__main__":
main()
# import sys
# input = sys.stdin.readline
#
# sys.setrecursionlimit(10 ** 7)
#
# (int(x)-1 for x in input().split())
# rstrip()
#
# def binary_search(*, ok, ng, func):
# while abs(ok - ng) > 1:
# mid = (ok + ng) // 2
# if func(mid):
# ok = mid
# else:
# ng = mid
# return ok
| false | 55.882353 | [
"-# 解説",
"-s = eval(input())",
"-k = int(eval(input()))",
"-st = set()",
"-for start in range(len(s)):",
"- for len_ in range(1, k + 1):",
"- st.add(s[start : start + len_])",
"-(*a,) = sorted(st)",
"-print((a[k - 1]))",
"-# 高々k文字",
"-# kが小さいので",
"-# 全列挙してソート",
"+def main():",
"+ S = eval(input())",
"+ N = len(S)",
"+ K = int(eval(input()))",
"+ tank = set()",
"+ for k in range(1, K + 1):",
"+ for i in range(N - k + 1):",
"+ t = S[i : i + k]",
"+ tank.add(t)",
"+ ans = sorted(tank)[K - 1]",
"+ print(ans)",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()",
"+# import sys",
"+# input = sys.stdin.readline",
"+#",
"+# sys.setrecursionlimit(10 ** 7)",
"+#",
"+# (int(x)-1 for x in input().split())",
"+# rstrip()",
"+#",
"+# def binary_search(*, ok, ng, func):",
"+# while abs(ok - ng) > 1:",
"+# mid = (ok + ng) // 2",
"+# if func(mid):",
"+# ok = mid",
"+# else:",
"+# ng = mid",
"+# return ok"
] | false | 0.049902 | 0.082713 | 0.60332 | [
"s849975387",
"s983615215"
] |
u475503988 | p03212 | python | s754301705 | s517549864 | 95 | 40 | 3,060 | 3,060 | Accepted | Accepted | 57.89 | N = int(eval(input()))
def dfs(s):
if int(s) > N:
return 0
ret = 1 if all(s.count(c) > 0 for c in "753") else 0
for c in "753":
ret += dfs(s + c)
return ret
print((dfs("0"))) | N = int(eval(input()))
ans = 0
def dfs(x, a, b, c):
global ans
if x > N:
return
if (a & b & c):
ans += 1
dfs(10 * x + 3, 1, b, c)
dfs(10 * x + 5, a, 1, c)
dfs(10 * x + 7, a, b, 1)
dfs(0, 0, 0, 0)
print(ans) | 9 | 15 | 206 | 256 | N = int(eval(input()))
def dfs(s):
if int(s) > N:
return 0
ret = 1 if all(s.count(c) > 0 for c in "753") else 0
for c in "753":
ret += dfs(s + c)
return ret
print((dfs("0")))
| N = int(eval(input()))
ans = 0
def dfs(x, a, b, c):
global ans
if x > N:
return
if a & b & c:
ans += 1
dfs(10 * x + 3, 1, b, c)
dfs(10 * x + 5, a, 1, c)
dfs(10 * x + 7, a, b, 1)
dfs(0, 0, 0, 0)
print(ans)
| false | 40 | [
"+ans = 0",
"-def dfs(s):",
"- if int(s) > N:",
"- return 0",
"- ret = 1 if all(s.count(c) > 0 for c in \"753\") else 0",
"- for c in \"753\":",
"- ret += dfs(s + c)",
"- return ret",
"+def dfs(x, a, b, c):",
"+ global ans",
"+ if x > N:",
"+ return",
"+ if a & b & c:",
"+ ans += 1",
"+ dfs(10 * x + 3, 1, b, c)",
"+ dfs(10 * x + 5, a, 1, c)",
"+ dfs(10 * x + 7, a, b, 1)",
"-print((dfs(\"0\")))",
"+dfs(0, 0, 0, 0)",
"+print(ans)"
] | false | 0.070358 | 0.056648 | 1.242014 | [
"s754301705",
"s517549864"
] |
u227082700 | p03775 | python | s263506709 | s029854067 | 34 | 30 | 3,060 | 3,060 | Accepted | Accepted | 11.76 | n=int(eval(input()));ans=10
for i in range(min(10**5,n)):
if n%(i+1)==0:ans=min(ans,max(len(str(i+1)),len(str(n//(i+1)))))
print(ans) | n=int(eval(input()))
ans=inf=float('inf')
for i in range(1,int(n**0.5)+1):
if n%i:continue
ans=max(len(str(n%i)),len(str(n//i)))
print(ans) | 4 | 6 | 132 | 142 | n = int(eval(input()))
ans = 10
for i in range(min(10**5, n)):
if n % (i + 1) == 0:
ans = min(ans, max(len(str(i + 1)), len(str(n // (i + 1)))))
print(ans)
| n = int(eval(input()))
ans = inf = float("inf")
for i in range(1, int(n**0.5) + 1):
if n % i:
continue
ans = max(len(str(n % i)), len(str(n // i)))
print(ans)
| false | 33.333333 | [
"-ans = 10",
"-for i in range(min(10**5, n)):",
"- if n % (i + 1) == 0:",
"- ans = min(ans, max(len(str(i + 1)), len(str(n // (i + 1)))))",
"+ans = inf = float(\"inf\")",
"+for i in range(1, int(n**0.5) + 1):",
"+ if n % i:",
"+ continue",
"+ ans = max(len(str(n % i)), len(str(n // i)))"
] | false | 0.144424 | 0.042941 | 3.363281 | [
"s263506709",
"s029854067"
] |
u762420987 | p03945 | python | s812420221 | s588145576 | 37 | 18 | 4,652 | 3,188 | Accepted | Accepted | 51.35 | S = list(eval(input()))
now = S[0]
ans = 0
for c in S[1:]:
if c != now:
ans += 1
now = c
print(ans)
| S = eval(input())
print((S.count("BW") + S.count("WB")))
| 8 | 2 | 121 | 50 | S = list(eval(input()))
now = S[0]
ans = 0
for c in S[1:]:
if c != now:
ans += 1
now = c
print(ans)
| S = eval(input())
print((S.count("BW") + S.count("WB")))
| false | 75 | [
"-S = list(eval(input()))",
"-now = S[0]",
"-ans = 0",
"-for c in S[1:]:",
"- if c != now:",
"- ans += 1",
"- now = c",
"-print(ans)",
"+S = eval(input())",
"+print((S.count(\"BW\") + S.count(\"WB\")))"
] | false | 0.049406 | 0.04403 | 1.122102 | [
"s812420221",
"s588145576"
] |
u254871849 | p03633 | python | s763828496 | s006950054 | 25 | 17 | 3,572 | 3,188 | Accepted | Accepted | 32 | import sys
from functools import reduce
def gcd(a, b):
while b:
a, b = b, a % b
return abs(a)
def lcm(a, b):
return abs(a // gcd(a, b) * b)
n, *t = list(map(int, sys.stdin.read().split()))
def main():
return reduce(lcm, t)
if __name__ == '__main__':
ans = main()
print(ans) | import sys
def gcd(a, b): return gcd(b, a % b) if b else abs(a)
def lcm(a, b): return abs(a // gcd(a, b) * b)
n, *t = list(map(int, sys.stdin.read().split()))
def main():
res = 1
for x in t:
res = lcm(res, x)
print(res)
if __name__ == '__main__':
main() | 19 | 15 | 322 | 290 | import sys
from functools import reduce
def gcd(a, b):
while b:
a, b = b, a % b
return abs(a)
def lcm(a, b):
return abs(a // gcd(a, b) * b)
n, *t = list(map(int, sys.stdin.read().split()))
def main():
return reduce(lcm, t)
if __name__ == "__main__":
ans = main()
print(ans)
| import sys
def gcd(a, b):
return gcd(b, a % b) if b else abs(a)
def lcm(a, b):
return abs(a // gcd(a, b) * b)
n, *t = list(map(int, sys.stdin.read().split()))
def main():
res = 1
for x in t:
res = lcm(res, x)
print(res)
if __name__ == "__main__":
main()
| false | 21.052632 | [
"-from functools import reduce",
"- while b:",
"- a, b = b, a % b",
"- return abs(a)",
"+ return gcd(b, a % b) if b else abs(a)",
"- return reduce(lcm, t)",
"+ res = 1",
"+ for x in t:",
"+ res = lcm(res, x)",
"+ print(res)",
"- ans = main()",
"- print(ans)",
"+ main()"
] | false | 0.034885 | 0.035994 | 0.96917 | [
"s763828496",
"s006950054"
] |
u021086907 | p02729 | python | s783785860 | s738074852 | 27 | 24 | 9,176 | 9,164 | Accepted | Accepted | 11.11 | N,M = list(map(int,input().split()))
if N ==1 and M ==1:
print((0))
elif N ==1 and M != 1:
print((int(M*(M-1)/2)))
elif N != 1 and M ==1:
print((int(N*(N-1)/2)))
else:
a = N*(N-1)
b = M*(M-1)
print((int((a+b)/2))) | N,M = list(map(int,input().split()))
a = N*(N-1)
b = M*(M-1)
print((int((a+b)/2))) | 11 | 4 | 237 | 78 | N, M = list(map(int, input().split()))
if N == 1 and M == 1:
print((0))
elif N == 1 and M != 1:
print((int(M * (M - 1) / 2)))
elif N != 1 and M == 1:
print((int(N * (N - 1) / 2)))
else:
a = N * (N - 1)
b = M * (M - 1)
print((int((a + b) / 2)))
| N, M = list(map(int, input().split()))
a = N * (N - 1)
b = M * (M - 1)
print((int((a + b) / 2)))
| false | 63.636364 | [
"-if N == 1 and M == 1:",
"- print((0))",
"-elif N == 1 and M != 1:",
"- print((int(M * (M - 1) / 2)))",
"-elif N != 1 and M == 1:",
"- print((int(N * (N - 1) / 2)))",
"-else:",
"- a = N * (N - 1)",
"- b = M * (M - 1)",
"- print((int((a + b) / 2)))",
"+a = N * (N - 1)",
"+b = M * (M - 1)",
"+print((int((a + b) / 2)))"
] | false | 0.040601 | 0.03906 | 1.03946 | [
"s783785860",
"s738074852"
] |
u270681687 | p03363 | python | s724693338 | s227808245 | 269 | 244 | 25,976 | 26,136 | Accepted | Accepted | 9.29 | n = int(eval(input()))
a = list(map(int, input().split()))
b = []
bn = 0
for i in range(n):
bn += a[i]
b.append(bn)
b.append(0)
b.sort()
num = []
i = 0
count = 0
for j in range(1, n+1):
if b[i] == b[j]:
count += 1
if j == n:
num.append(count)
else:
i = j
num.append(count)
count = 0
ans = 0
for i in num:
ans += ((i+1) * i // 2)
print(ans) | n = int(eval(input()))
a = list(map(int, input().split()))
cum = [0] * (n+1)
for i in range(n):
cum[i+1] = cum[i] + a[i]
cum.sort()
num = cum[0]
count = 1
ans = 0
for i in range(n):
if cum[i+1] == num:
count += 1
else:
ans += count * (count - 1) // 2
num = cum[i+1]
count = 1
if count > 1:
ans += count * (count - 1) // 2
print(ans)
| 28 | 25 | 435 | 405 | n = int(eval(input()))
a = list(map(int, input().split()))
b = []
bn = 0
for i in range(n):
bn += a[i]
b.append(bn)
b.append(0)
b.sort()
num = []
i = 0
count = 0
for j in range(1, n + 1):
if b[i] == b[j]:
count += 1
if j == n:
num.append(count)
else:
i = j
num.append(count)
count = 0
ans = 0
for i in num:
ans += (i + 1) * i // 2
print(ans)
| n = int(eval(input()))
a = list(map(int, input().split()))
cum = [0] * (n + 1)
for i in range(n):
cum[i + 1] = cum[i] + a[i]
cum.sort()
num = cum[0]
count = 1
ans = 0
for i in range(n):
if cum[i + 1] == num:
count += 1
else:
ans += count * (count - 1) // 2
num = cum[i + 1]
count = 1
if count > 1:
ans += count * (count - 1) // 2
print(ans)
| false | 10.714286 | [
"-b = []",
"-bn = 0",
"+cum = [0] * (n + 1)",
"- bn += a[i]",
"- b.append(bn)",
"-b.append(0)",
"-b.sort()",
"-num = []",
"-i = 0",
"-count = 0",
"-for j in range(1, n + 1):",
"- if b[i] == b[j]:",
"+ cum[i + 1] = cum[i] + a[i]",
"+cum.sort()",
"+num = cum[0]",
"+count = 1",
"+ans = 0",
"+for i in range(n):",
"+ if cum[i + 1] == num:",
"- if j == n:",
"- num.append(count)",
"- i = j",
"- num.append(count)",
"- count = 0",
"-ans = 0",
"-for i in num:",
"- ans += (i + 1) * i // 2",
"+ ans += count * (count - 1) // 2",
"+ num = cum[i + 1]",
"+ count = 1",
"+if count > 1:",
"+ ans += count * (count - 1) // 2"
] | false | 0.047315 | 0.109428 | 0.432388 | [
"s724693338",
"s227808245"
] |
u038676814 | p03137 | python | s016434720 | s776380076 | 146 | 111 | 13,968 | 19,868 | Accepted | Accepted | 23.97 | N,M = list(map(int, input().split(" ")))
XList = list(map(int,input().split()))
XList = sorted(XList)
deltaList = [0]
for i in range(M-1) :
deltaList.append(XList[i+1] - XList[i])
deltaList = sorted(deltaList, reverse=True)
for i in range(N-1) :
deltaList[i] = 0
if i == len(deltaList)-1 :
break
print((sum(deltaList))) | n,m = list(map(int, input().split(" ")))
xList = [int(i) for i in input().split(" ")]
xList = sorted(xList)
dList = [0]
for i in range(len(xList) -1) :
dList.append(xList[i+1] - xList[i])
dList = sorted(dList, reverse=True)
for i in range(n-1) :
dList[i] = 0
if(i == len(dList) -1) :
break
print((sum(dList))) | 16 | 13 | 350 | 338 | N, M = list(map(int, input().split(" ")))
XList = list(map(int, input().split()))
XList = sorted(XList)
deltaList = [0]
for i in range(M - 1):
deltaList.append(XList[i + 1] - XList[i])
deltaList = sorted(deltaList, reverse=True)
for i in range(N - 1):
deltaList[i] = 0
if i == len(deltaList) - 1:
break
print((sum(deltaList)))
| n, m = list(map(int, input().split(" ")))
xList = [int(i) for i in input().split(" ")]
xList = sorted(xList)
dList = [0]
for i in range(len(xList) - 1):
dList.append(xList[i + 1] - xList[i])
dList = sorted(dList, reverse=True)
for i in range(n - 1):
dList[i] = 0
if i == len(dList) - 1:
break
print((sum(dList)))
| false | 18.75 | [
"-N, M = list(map(int, input().split(\" \")))",
"-XList = list(map(int, input().split()))",
"-XList = sorted(XList)",
"-deltaList = [0]",
"-for i in range(M - 1):",
"- deltaList.append(XList[i + 1] - XList[i])",
"-deltaList = sorted(deltaList, reverse=True)",
"-for i in range(N - 1):",
"- deltaList[i] = 0",
"- if i == len(deltaList) - 1:",
"+n, m = list(map(int, input().split(\" \")))",
"+xList = [int(i) for i in input().split(\" \")]",
"+xList = sorted(xList)",
"+dList = [0]",
"+for i in range(len(xList) - 1):",
"+ dList.append(xList[i + 1] - xList[i])",
"+dList = sorted(dList, reverse=True)",
"+for i in range(n - 1):",
"+ dList[i] = 0",
"+ if i == len(dList) - 1:",
"-print((sum(deltaList)))",
"+print((sum(dList)))"
] | false | 0.035593 | 0.036446 | 0.976601 | [
"s016434720",
"s776380076"
] |
u691018832 | p02850 | python | s634317911 | s933105721 | 514 | 412 | 44,764 | 45,704 | Accepted | Accepted | 19.84 | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
n = int(readline())
ab = [list(map(int, readline().split())) for i in range(n - 1)]
gragh = [[] for j in range(n + 1)]
for a, b in ab:
gragh[a].append(b)
gragh[b].append(a)
root = 1
parent = [0] * (n + 1)
stack = [root]
order = []
while stack:
x = stack.pop()
order.append(x)
for y in gragh[x]:
if y == parent[x]:
continue
parent[y] = x
stack.append(y)
color = [-1] * (n + 1)
for x in order:
ng = color[x]
cnt = 1
for y in gragh[x]:
if y == parent[x]:
continue
if cnt == ng:
cnt += 1
color[y] = cnt
cnt += 1
ans = []
append = ans.append
for a, b in ab:
if parent[a] == b:
append(color[a])
else:
append(color[b])
print((max(ans)))
print(('\n'.join(map(str, ans))))
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
from collections import deque
n = int(readline())
graph = [[] for _ in range(n + 1)]
for i in range(n - 1):
a, b = list(map(int, readline().split()))
graph[a].append((b, i))
graph[b].append((a, i))
color = [-1] * (n + 1)
color[1] = -2
ans = [0] * (n - 1)
def bfs(s):
stack = deque([s])
while stack:
num = 1
now = stack.pop()
for next, idx in graph[now]:
if color[next] != -1:
continue
if color[now] == num:
num += 1
color[next] = num
ans[idx] = num
num += 1
stack.append(next)
bfs(1)
print((max(ans)))
print(('\n'.join(map(str, ans))))
| 46 | 37 | 973 | 862 | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
n = int(readline())
ab = [list(map(int, readline().split())) for i in range(n - 1)]
gragh = [[] for j in range(n + 1)]
for a, b in ab:
gragh[a].append(b)
gragh[b].append(a)
root = 1
parent = [0] * (n + 1)
stack = [root]
order = []
while stack:
x = stack.pop()
order.append(x)
for y in gragh[x]:
if y == parent[x]:
continue
parent[y] = x
stack.append(y)
color = [-1] * (n + 1)
for x in order:
ng = color[x]
cnt = 1
for y in gragh[x]:
if y == parent[x]:
continue
if cnt == ng:
cnt += 1
color[y] = cnt
cnt += 1
ans = []
append = ans.append
for a, b in ab:
if parent[a] == b:
append(color[a])
else:
append(color[b])
print((max(ans)))
print(("\n".join(map(str, ans))))
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10**7)
from collections import deque
n = int(readline())
graph = [[] for _ in range(n + 1)]
for i in range(n - 1):
a, b = list(map(int, readline().split()))
graph[a].append((b, i))
graph[b].append((a, i))
color = [-1] * (n + 1)
color[1] = -2
ans = [0] * (n - 1)
def bfs(s):
stack = deque([s])
while stack:
num = 1
now = stack.pop()
for next, idx in graph[now]:
if color[next] != -1:
continue
if color[now] == num:
num += 1
color[next] = num
ans[idx] = num
num += 1
stack.append(next)
bfs(1)
print((max(ans)))
print(("\n".join(map(str, ans))))
| false | 19.565217 | [
"+sys.setrecursionlimit(10**7)",
"+from collections import deque",
"+",
"-ab = [list(map(int, readline().split())) for i in range(n - 1)]",
"-gragh = [[] for j in range(n + 1)]",
"-for a, b in ab:",
"- gragh[a].append(b)",
"- gragh[b].append(a)",
"-root = 1",
"-parent = [0] * (n + 1)",
"-stack = [root]",
"-order = []",
"-while stack:",
"- x = stack.pop()",
"- order.append(x)",
"- for y in gragh[x]:",
"- if y == parent[x]:",
"- continue",
"- parent[y] = x",
"- stack.append(y)",
"+graph = [[] for _ in range(n + 1)]",
"+for i in range(n - 1):",
"+ a, b = list(map(int, readline().split()))",
"+ graph[a].append((b, i))",
"+ graph[b].append((a, i))",
"-for x in order:",
"- ng = color[x]",
"- cnt = 1",
"- for y in gragh[x]:",
"- if y == parent[x]:",
"- continue",
"- if cnt == ng:",
"- cnt += 1",
"- color[y] = cnt",
"- cnt += 1",
"-ans = []",
"-append = ans.append",
"-for a, b in ab:",
"- if parent[a] == b:",
"- append(color[a])",
"- else:",
"- append(color[b])",
"+color[1] = -2",
"+ans = [0] * (n - 1)",
"+",
"+",
"+def bfs(s):",
"+ stack = deque([s])",
"+ while stack:",
"+ num = 1",
"+ now = stack.pop()",
"+ for next, idx in graph[now]:",
"+ if color[next] != -1:",
"+ continue",
"+ if color[now] == num:",
"+ num += 1",
"+ color[next] = num",
"+ ans[idx] = num",
"+ num += 1",
"+ stack.append(next)",
"+",
"+",
"+bfs(1)"
] | false | 0.009744 | 0.043865 | 0.222128 | [
"s634317911",
"s933105721"
] |
u684241248 | p02241 | python | s959168566 | s603362835 | 370 | 320 | 6,472 | 6,472 | Accepted | Accepted | 13.51 | # -*- coding: utf-8 -*-
def prim(edges, *, start=0, adj_matrix=False, default_value=float('inf')):
'''
Returns the Minimum Spanning Tree(MST) of a given graph
# sample input when given as adjacency matrix
edges = [[0, 2, 5, 4, inf, inf], # node 0
[2, 0, inf, 3, 6, inf], # node 1
[5, inf, 0, 2, inf, 6], # node 2
[4, 3, 2, 0, 2, inf], # node 3
[inf, 6, inf, 2, 0, 4], # node 4
[inf, inf, 6, inf, 4, 0]] # node 5
# sample input when given not as adjacency matrix
edges = [[(1, 2), (2, 5), (3, 4)], # node 0
[(0, 2), (3, 3), (4, 6)], # node 1
[(0, 5), (3, 2), (5, 6)], # node 2
[(0, 4), (1, 3), (2, 2), (4, 2)], # node 3
[(1, 6), (3, 2), (5, 4)], # node 4
[(2, 6), (4, 4)]] # node 5
'''
n = len(edges)
mst = []
cost = 0
T = [start]
while True:
tmp_edges = [(cost, (u, v)) for u in T for v, cost in enumerate(edges[u]) if cost != default_value and v not in T] if adj_matrix else\
[(cost, (u, v)) for u in T for v, cost in edges[u] if v not in T]
if tmp_edges:
min_cost, min_edge = min(tmp_edges)
mst.append(min_edge)
cost += min_cost
T.append(min_edge[1])
else:
if len(mst) != n - 1:
raise NoSpanningError(
'There is no spanning tree in this graph (search started from node{})'.
format(start))
else:
return mst, cost
class NoSpanningError(Exception):
pass
if __name__ == '__main__':
'''
an example of using this function
AIZU ONLINE JUDGE - ALDS_1_12_A
'''
n = int(input())
edges = [[int(cost) if int(cost) != -1 else float('inf') for cost in input().split()] for i in range(n)]
print(prim(edges, adj_matrix=True)[1])
| # -*- coding: utf-8 -*-
def prim(edges, *, start=0, adj_matrix=False, default_value=float('inf')):
'''
Returns the Minimum Spanning Tree(MST) of a given graph
# sample input when given not as adjacency list (generally works faster)
edges = [[(1, 2), (2, 5), (3, 4)], # node 0
[(0, 2), (3, 3), (4, 6)], # node 1
[(0, 5), (3, 2), (5, 6)], # node 2
[(0, 4), (1, 3), (2, 2), (4, 2)], # node 3
[(1, 6), (3, 2), (5, 4)], # node 4
[(2, 6), (4, 4)]] # node 5
# sample input when given as adjacency matrix
edges = [[0, 2, 5, 4, inf, inf], # node 0
[2, 0, inf, 3, 6, inf], # node 1
[5, inf, 0, 2, inf, 6], # node 2
[4, 3, 2, 0, 2, inf], # node 3
[inf, 6, inf, 2, 0, 4], # node 4
[inf, inf, 6, inf, 4, 0]] # node 5
'''
n = len(edges)
mst = []
cost = 0
T = [start]
while True:
tmp_edges = [(cost, (u, v)) for u in T for v, cost in enumerate(edges[u]) if cost != default_value and v not in T] if adj_matrix else\
[(cost, (u, v)) for u in T for v, cost in edges[u] if v not in T]
if tmp_edges:
min_cost, min_edge = min(tmp_edges)
mst.append(min_edge)
cost += min_cost
T.append(min_edge[1])
else:
if len(mst) != n - 1:
raise NoSpanningError(
'There is no spanning tree in this graph (search started from node{})'.
format(start))
else:
return mst, cost
class NoSpanningError(Exception):
pass
if __name__ == '__main__':
'''
an example of using this function
AIZU ONLINE JUDGE - ALDS_1_12_A
'''
n = int(input())
edges = [[int(cost) if int(cost) != -1 else float('inf') for cost in input().split()] for i in range(n)]
print(prim(edges, adj_matrix=True)[1])
| 62 | 62 | 2,096 | 2,119 | # -*- coding: utf-8 -*-
def prim(edges, *, start=0, adj_matrix=False, default_value=float("inf")):
"""
Returns the Minimum Spanning Tree(MST) of a given graph
# sample input when given as adjacency matrix
edges = [[0, 2, 5, 4, inf, inf], # node 0
[2, 0, inf, 3, 6, inf], # node 1
[5, inf, 0, 2, inf, 6], # node 2
[4, 3, 2, 0, 2, inf], # node 3
[inf, 6, inf, 2, 0, 4], # node 4
[inf, inf, 6, inf, 4, 0]] # node 5
# sample input when given not as adjacency matrix
edges = [[(1, 2), (2, 5), (3, 4)], # node 0
[(0, 2), (3, 3), (4, 6)], # node 1
[(0, 5), (3, 2), (5, 6)], # node 2
[(0, 4), (1, 3), (2, 2), (4, 2)], # node 3
[(1, 6), (3, 2), (5, 4)], # node 4
[(2, 6), (4, 4)]] # node 5
"""
n = len(edges)
mst = []
cost = 0
T = [start]
while True:
tmp_edges = (
[
(cost, (u, v))
for u in T
for v, cost in enumerate(edges[u])
if cost != default_value and v not in T
]
if adj_matrix
else [(cost, (u, v)) for u in T for v, cost in edges[u] if v not in T]
)
if tmp_edges:
min_cost, min_edge = min(tmp_edges)
mst.append(min_edge)
cost += min_cost
T.append(min_edge[1])
else:
if len(mst) != n - 1:
raise NoSpanningError(
"There is no spanning tree in this graph (search started from node{})".format(
start
)
)
else:
return mst, cost
class NoSpanningError(Exception):
pass
if __name__ == "__main__":
"""
an example of using this function
AIZU ONLINE JUDGE - ALDS_1_12_A
"""
n = int(input())
edges = [
[int(cost) if int(cost) != -1 else float("inf") for cost in input().split()]
for i in range(n)
]
print(prim(edges, adj_matrix=True)[1])
| # -*- coding: utf-8 -*-
def prim(edges, *, start=0, adj_matrix=False, default_value=float("inf")):
"""
Returns the Minimum Spanning Tree(MST) of a given graph
# sample input when given not as adjacency list (generally works faster)
edges = [[(1, 2), (2, 5), (3, 4)], # node 0
[(0, 2), (3, 3), (4, 6)], # node 1
[(0, 5), (3, 2), (5, 6)], # node 2
[(0, 4), (1, 3), (2, 2), (4, 2)], # node 3
[(1, 6), (3, 2), (5, 4)], # node 4
[(2, 6), (4, 4)]] # node 5
# sample input when given as adjacency matrix
edges = [[0, 2, 5, 4, inf, inf], # node 0
[2, 0, inf, 3, 6, inf], # node 1
[5, inf, 0, 2, inf, 6], # node 2
[4, 3, 2, 0, 2, inf], # node 3
[inf, 6, inf, 2, 0, 4], # node 4
[inf, inf, 6, inf, 4, 0]] # node 5
"""
n = len(edges)
mst = []
cost = 0
T = [start]
while True:
tmp_edges = (
[
(cost, (u, v))
for u in T
for v, cost in enumerate(edges[u])
if cost != default_value and v not in T
]
if adj_matrix
else [(cost, (u, v)) for u in T for v, cost in edges[u] if v not in T]
)
if tmp_edges:
min_cost, min_edge = min(tmp_edges)
mst.append(min_edge)
cost += min_cost
T.append(min_edge[1])
else:
if len(mst) != n - 1:
raise NoSpanningError(
"There is no spanning tree in this graph (search started from node{})".format(
start
)
)
else:
return mst, cost
class NoSpanningError(Exception):
pass
if __name__ == "__main__":
"""
an example of using this function
AIZU ONLINE JUDGE - ALDS_1_12_A
"""
n = int(input())
edges = [
[int(cost) if int(cost) != -1 else float("inf") for cost in input().split()]
for i in range(n)
]
print(prim(edges, adj_matrix=True)[1])
| false | 0 | [
"+ # sample input when given not as adjacency list (generally works faster)",
"+ edges = [[(1, 2), (2, 5), (3, 4)], # node 0",
"+ [(0, 2), (3, 3), (4, 6)], # node 1",
"+ [(0, 5), (3, 2), (5, 6)], # node 2",
"+ [(0, 4), (1, 3), (2, 2), (4, 2)], # node 3",
"+ [(1, 6), (3, 2), (5, 4)], # node 4",
"+ [(2, 6), (4, 4)]] # node 5",
"- # sample input when given not as adjacency matrix",
"- edges = [[(1, 2), (2, 5), (3, 4)], # node 0",
"- [(0, 2), (3, 3), (4, 6)], # node 1",
"- [(0, 5), (3, 2), (5, 6)], # node 2",
"- [(0, 4), (1, 3), (2, 2), (4, 2)], # node 3",
"- [(1, 6), (3, 2), (5, 4)], # node 4",
"- [(2, 6), (4, 4)]] # node 5"
] | false | 0.03956 | 0.03849 | 1.027798 | [
"s959168566",
"s603362835"
] |
u088751997 | p03485 | python | s667562652 | s974140512 | 25 | 19 | 9,152 | 9,152 | Accepted | Accepted | 24 | a,b = list(map(int,input().split()))
c = int((a+b+1)/2)
print(c) | a,b = list(map(int,input().split()))
print(((a+b+1)//2)) | 3 | 2 | 60 | 49 | a, b = list(map(int, input().split()))
c = int((a + b + 1) / 2)
print(c)
| a, b = list(map(int, input().split()))
print(((a + b + 1) // 2))
| false | 33.333333 | [
"-c = int((a + b + 1) / 2)",
"-print(c)",
"+print(((a + b + 1) // 2))"
] | false | 0.039424 | 0.039233 | 1.004851 | [
"s667562652",
"s974140512"
] |
u242679311 | p03550 | python | s885822776 | s761610788 | 1,527 | 19 | 3,188 | 3,188 | Accepted | Accepted | 98.76 | n,z,w = list(map(int,input().split()))
a = list(map(int,input().split()))
xp = [0]*(n)
yp = [10000000000]*(n)
xp[0] = abs(a[n-1]-w)
for i in reversed(list(range(n))):
for j in range(i+1,n):
xp[i] = max(xp[i], yp[j])
yp[i] = min(yp[i], xp[j])
xp[i] = max(xp[i], abs(a[i-1]-a[n-1]))
yp[i] = min(yp[i], abs(a[i-1]-a[n-1]))
print((xp[0])) | n,z,w = list(map(int,input().split()))
a = list(map(int,input().split()))
if n == 1:
print((abs(a[0]-w)))
else:
print((max(abs(a[n-1]-w),abs(a[n-1]-a[n-2])))) | 12 | 6 | 359 | 161 | n, z, w = list(map(int, input().split()))
a = list(map(int, input().split()))
xp = [0] * (n)
yp = [10000000000] * (n)
xp[0] = abs(a[n - 1] - w)
for i in reversed(list(range(n))):
for j in range(i + 1, n):
xp[i] = max(xp[i], yp[j])
yp[i] = min(yp[i], xp[j])
xp[i] = max(xp[i], abs(a[i - 1] - a[n - 1]))
yp[i] = min(yp[i], abs(a[i - 1] - a[n - 1]))
print((xp[0]))
| n, z, w = list(map(int, input().split()))
a = list(map(int, input().split()))
if n == 1:
print((abs(a[0] - w)))
else:
print((max(abs(a[n - 1] - w), abs(a[n - 1] - a[n - 2]))))
| false | 50 | [
"-xp = [0] * (n)",
"-yp = [10000000000] * (n)",
"-xp[0] = abs(a[n - 1] - w)",
"-for i in reversed(list(range(n))):",
"- for j in range(i + 1, n):",
"- xp[i] = max(xp[i], yp[j])",
"- yp[i] = min(yp[i], xp[j])",
"- xp[i] = max(xp[i], abs(a[i - 1] - a[n - 1]))",
"- yp[i] = min(yp[i], abs(a[i - 1] - a[n - 1]))",
"-print((xp[0]))",
"+if n == 1:",
"+ print((abs(a[0] - w)))",
"+else:",
"+ print((max(abs(a[n - 1] - w), abs(a[n - 1] - a[n - 2]))))"
] | false | 0.08346 | 0.048249 | 1.729785 | [
"s885822776",
"s761610788"
] |
u160244242 | p03275 | python | s427511941 | s176510106 | 1,417 | 951 | 133,356 | 131,384 | Accepted | Accepted | 32.89 | from itertools import accumulate
from math import ceil
N = int(eval(input()))
A = list(map(int, input().split()))
if N == 1:
print((A[0]))
exit()
class BinaryIndexedTree:
def __init__(self, n):
self.size = n
self.bit = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.bit[i]
i -= (i & -i)
return s
def add(self, i, x):
while i <= self.size:
self.bit[i] += x
i += (i & -i)
def reset(self):
self.bit = [0] * (self.size + 1)
BIT = BinaryIndexedTree(N) # Binaryの先頭の分
lo, hi = -1, 10 ** 9 + 1
while hi - lo > 1:
# Xは中央値候補
X = (hi + lo) // 2
# X以上なら1、X未満なら-1に変換
Binary = [(1 if a >= X else -1) for a in A]
# 累積和をとる
Binary = list(accumulate(Binary))
# BITを初期化
BIT.reset()
# 転倒数っぽいものを数える
inversion = 0
Binary_sorted = {b: i for i, b in enumerate(sorted(Binary), start=1)}
for j, b in enumerate(Binary):
inversion += BIT.sum(Binary_sorted[b]) + (b >= 0)
BIT.add(Binary_sorted[b], 1)
if inversion >= ceil((N * (N + 1) / 2) / 2):
lo = X
else:
hi = X
print(lo) | import math
n = int(input())
lst = list(map(int, input().split()))
class Bit:
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.tree[i] += x
i += i & -i
def judge(x, lst, n):
length = len(lst)
all_pair = (length*(length-1) // 2) + length
lst_r = [-1 if i < x else 1 for i in lst]
lst_accum = []
a = 0
for i in lst_r:
a += i
lst_accum.append(a)
bit = Bit(n)
lst_accum_sorted = {b: i for i, b in enumerate(sorted(lst_accum), start=1)}
count = 0
for j, b in enumerate(lst_accum):
count += bit.sum(lst_accum_sorted[b]) + (b >= 0)
bit.add(lst_accum_sorted[b], 1)
if count >= math.ceil(all_pair/2):
return True
else:
return False
sorted_lst = sorted(lst)
low = 0
high = len(lst) - 1
while high - low >1:
t = (low+high) // 2
i = sorted_lst[t]
if judge(i, lst, n):
low = t
else:
high = t
print(sorted_lst[high]) if judge(sorted_lst[high], lst, n) else print(sorted_lst[low])
| 60 | 60 | 1,258 | 1,357 | from itertools import accumulate
from math import ceil
N = int(eval(input()))
A = list(map(int, input().split()))
if N == 1:
print((A[0]))
exit()
class BinaryIndexedTree:
def __init__(self, n):
self.size = n
self.bit = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.bit[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.bit[i] += x
i += i & -i
def reset(self):
self.bit = [0] * (self.size + 1)
BIT = BinaryIndexedTree(N) # Binaryの先頭の分
lo, hi = -1, 10**9 + 1
while hi - lo > 1:
# Xは中央値候補
X = (hi + lo) // 2
# X以上なら1、X未満なら-1に変換
Binary = [(1 if a >= X else -1) for a in A]
# 累積和をとる
Binary = list(accumulate(Binary))
# BITを初期化
BIT.reset()
# 転倒数っぽいものを数える
inversion = 0
Binary_sorted = {b: i for i, b in enumerate(sorted(Binary), start=1)}
for j, b in enumerate(Binary):
inversion += BIT.sum(Binary_sorted[b]) + (b >= 0)
BIT.add(Binary_sorted[b], 1)
if inversion >= ceil((N * (N + 1) / 2) / 2):
lo = X
else:
hi = X
print(lo)
| import math
n = int(input())
lst = list(map(int, input().split()))
class Bit:
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.tree[i] += x
i += i & -i
def judge(x, lst, n):
length = len(lst)
all_pair = (length * (length - 1) // 2) + length
lst_r = [-1 if i < x else 1 for i in lst]
lst_accum = []
a = 0
for i in lst_r:
a += i
lst_accum.append(a)
bit = Bit(n)
lst_accum_sorted = {b: i for i, b in enumerate(sorted(lst_accum), start=1)}
count = 0
for j, b in enumerate(lst_accum):
count += bit.sum(lst_accum_sorted[b]) + (b >= 0)
bit.add(lst_accum_sorted[b], 1)
if count >= math.ceil(all_pair / 2):
return True
else:
return False
sorted_lst = sorted(lst)
low = 0
high = len(lst) - 1
while high - low > 1:
t = (low + high) // 2
i = sorted_lst[t]
if judge(i, lst, n):
low = t
else:
high = t
print(sorted_lst[high]) if judge(sorted_lst[high], lst, n) else print(sorted_lst[low])
| false | 0 | [
"-from itertools import accumulate",
"-from math import ceil",
"+import math",
"-N = int(eval(input()))",
"-A = list(map(int, input().split()))",
"-if N == 1:",
"- print((A[0]))",
"- exit()",
"+n = int(input())",
"+lst = list(map(int, input().split()))",
"-class BinaryIndexedTree:",
"+class Bit:",
"- self.bit = [0] * (n + 1)",
"+ self.tree = [0] * (n + 1)",
"- s += self.bit[i]",
"+ s += self.tree[i]",
"- self.bit[i] += x",
"+ self.tree[i] += x",
"- def reset(self):",
"- self.bit = [0] * (self.size + 1)",
"+",
"+def judge(x, lst, n):",
"+ length = len(lst)",
"+ all_pair = (length * (length - 1) // 2) + length",
"+ lst_r = [-1 if i < x else 1 for i in lst]",
"+ lst_accum = []",
"+ a = 0",
"+ for i in lst_r:",
"+ a += i",
"+ lst_accum.append(a)",
"+ bit = Bit(n)",
"+ lst_accum_sorted = {b: i for i, b in enumerate(sorted(lst_accum), start=1)}",
"+ count = 0",
"+ for j, b in enumerate(lst_accum):",
"+ count += bit.sum(lst_accum_sorted[b]) + (b >= 0)",
"+ bit.add(lst_accum_sorted[b], 1)",
"+ if count >= math.ceil(all_pair / 2):",
"+ return True",
"+ else:",
"+ return False",
"-BIT = BinaryIndexedTree(N) # Binaryの先頭の分",
"-lo, hi = -1, 10**9 + 1",
"-while hi - lo > 1:",
"- # Xは中央値候補",
"- X = (hi + lo) // 2",
"- # X以上なら1、X未満なら-1に変換",
"- Binary = [(1 if a >= X else -1) for a in A]",
"- # 累積和をとる",
"- Binary = list(accumulate(Binary))",
"- # BITを初期化",
"- BIT.reset()",
"- # 転倒数っぽいものを数える",
"- inversion = 0",
"- Binary_sorted = {b: i for i, b in enumerate(sorted(Binary), start=1)}",
"- for j, b in enumerate(Binary):",
"- inversion += BIT.sum(Binary_sorted[b]) + (b >= 0)",
"- BIT.add(Binary_sorted[b], 1)",
"- if inversion >= ceil((N * (N + 1) / 2) / 2):",
"- lo = X",
"+sorted_lst = sorted(lst)",
"+low = 0",
"+high = len(lst) - 1",
"+while high - low > 1:",
"+ t = (low + high) // 2",
"+ i = sorted_lst[t]",
"+ if judge(i, lst, n):",
"+ low = t",
"- hi = X",
"-print(lo)",
"+ high = t",
"+print(sorted_lst[high]) if judge(sorted_lst[high], lst, n) else print(sorted_lst[low])"
] | false | 0.101156 | 0.08033 | 1.259266 | [
"s427511941",
"s176510106"
] |
u332385682 | p03807 | python | s198917764 | s080367161 | 77 | 71 | 14,108 | 14,232 | Accepted | Accepted | 7.79 | import sys
def debug(x, table):
for name, val in table.items():
if x is val:
print('DEBUG:{} -> {}'.format(name, val), file=sys.stderr)
return None
def solve():
N = int(input())
A = [int(i) for i in input().split()]
num_ev = 0
num_od = 0
for a in A:
if a % 2 == 0:
num_ev += 1
else:
num_od += 1
if num_od % 2 == 1:
print('NO')
return None
else:
num_ev += num_od // 2
if num_ev >= 1:
print('YES')
else:
print('NO')
if __name__ == '__main__':
solve()
| import sys
def debug(x, table):
for name, val in table.items():
if x is val:
print('DEBUG:{} -> {}'.format(name, val), file=sys.stderr)
return None
def solve():
N = int(input())
A = [int(i) for i in input().split()]
yes = 'YES'
no = 'NO'
num_od = 0
for a in A:
if a % 2 == 1:
num_od += 1
if num_od % 2 == 1:
print(no)
else:
print(yes)
if __name__ == '__main__':
solve()
| 34 | 27 | 660 | 509 | import sys
def debug(x, table):
for name, val in table.items():
if x is val:
print("DEBUG:{} -> {}".format(name, val), file=sys.stderr)
return None
def solve():
N = int(input())
A = [int(i) for i in input().split()]
num_ev = 0
num_od = 0
for a in A:
if a % 2 == 0:
num_ev += 1
else:
num_od += 1
if num_od % 2 == 1:
print("NO")
return None
else:
num_ev += num_od // 2
if num_ev >= 1:
print("YES")
else:
print("NO")
if __name__ == "__main__":
solve()
| import sys
def debug(x, table):
for name, val in table.items():
if x is val:
print("DEBUG:{} -> {}".format(name, val), file=sys.stderr)
return None
def solve():
N = int(input())
A = [int(i) for i in input().split()]
yes = "YES"
no = "NO"
num_od = 0
for a in A:
if a % 2 == 1:
num_od += 1
if num_od % 2 == 1:
print(no)
else:
print(yes)
if __name__ == "__main__":
solve()
| false | 20.588235 | [
"- num_ev = 0",
"+ yes = \"YES\"",
"+ no = \"NO\"",
"- if a % 2 == 0:",
"- num_ev += 1",
"- else:",
"+ if a % 2 == 1:",
"- print(\"NO\")",
"- return None",
"+ print(no)",
"- num_ev += num_od // 2",
"- if num_ev >= 1:",
"- print(\"YES\")",
"- else:",
"- print(\"NO\")",
"+ print(yes)"
] | false | 0.171546 | 0.074466 | 2.303666 | [
"s198917764",
"s080367161"
] |
u340781749 | p03431 | python | s774005063 | s944030791 | 682 | 360 | 44,908 | 22,772 | Accepted | Accepted | 47.21 | def solve(n, k):
MOD = 998244353
if n > k:
return 0
if n == 1:
return pow(2, k - 1, MOD)
invs = [1] * (k + 1)
pf, kf = 1, 1
for m in range(2, k + 1):
pf = kf
kf *= m
kf %= MOD
invs[m] = pow(kf, MOD - 2, MOD)
ans = 0
if k & 1 == 0:
r = k >> 1
s = k - n + 1
ans = pf * (invs[r] * invs[r - 1] - invs[s] * invs[k - s - 1]) % MOD
for r in range(k // 2 + 1, k + 1):
if r * 2 >= n + k:
ans += kf * invs[r] * invs[k - r]
else:
s = r * 2 - n + 1
ans += kf * (invs[r] * invs[k - r] - invs[s] * invs[k - s])
ans %= MOD
return ans
print((solve(*list(map(int, input().split())))))
| def solve(n, k):
MOD = 998244353
if n > k:
return 0
if n == 1:
return pow(2, k - 1, MOD)
pf, kf = 1, 1
for m in range(2, k + 1):
pf = kf
kf *= m
kf %= MOD
inv = pow(kf, MOD - 2, MOD)
invs = [1] * (k + 1)
invs[k] = inv
for m in range(k, 1, -1):
inv *= m
inv %= MOD
invs[m - 1] = inv
ans = 0
if k & 1 == 0:
r = k >> 1
s = k - n + 1
ans = pf * (invs[r] * invs[r - 1] - invs[s] * invs[k - s - 1]) % MOD
for r in range(k // 2 + 1, k + 1):
if r * 2 >= n + k:
ans += kf * invs[r] * invs[k - r]
else:
s = r * 2 - n + 1
ans += kf * (invs[r] * invs[k - r] - invs[s] * invs[k - s])
ans %= MOD
return ans
print((solve(*list(map(int, input().split())))))
| 33 | 39 | 770 | 879 | def solve(n, k):
MOD = 998244353
if n > k:
return 0
if n == 1:
return pow(2, k - 1, MOD)
invs = [1] * (k + 1)
pf, kf = 1, 1
for m in range(2, k + 1):
pf = kf
kf *= m
kf %= MOD
invs[m] = pow(kf, MOD - 2, MOD)
ans = 0
if k & 1 == 0:
r = k >> 1
s = k - n + 1
ans = pf * (invs[r] * invs[r - 1] - invs[s] * invs[k - s - 1]) % MOD
for r in range(k // 2 + 1, k + 1):
if r * 2 >= n + k:
ans += kf * invs[r] * invs[k - r]
else:
s = r * 2 - n + 1
ans += kf * (invs[r] * invs[k - r] - invs[s] * invs[k - s])
ans %= MOD
return ans
print((solve(*list(map(int, input().split())))))
| def solve(n, k):
MOD = 998244353
if n > k:
return 0
if n == 1:
return pow(2, k - 1, MOD)
pf, kf = 1, 1
for m in range(2, k + 1):
pf = kf
kf *= m
kf %= MOD
inv = pow(kf, MOD - 2, MOD)
invs = [1] * (k + 1)
invs[k] = inv
for m in range(k, 1, -1):
inv *= m
inv %= MOD
invs[m - 1] = inv
ans = 0
if k & 1 == 0:
r = k >> 1
s = k - n + 1
ans = pf * (invs[r] * invs[r - 1] - invs[s] * invs[k - s - 1]) % MOD
for r in range(k // 2 + 1, k + 1):
if r * 2 >= n + k:
ans += kf * invs[r] * invs[k - r]
else:
s = r * 2 - n + 1
ans += kf * (invs[r] * invs[k - r] - invs[s] * invs[k - s])
ans %= MOD
return ans
print((solve(*list(map(int, input().split())))))
| false | 15.384615 | [
"- invs = [1] * (k + 1)",
"- invs[m] = pow(kf, MOD - 2, MOD)",
"+ inv = pow(kf, MOD - 2, MOD)",
"+ invs = [1] * (k + 1)",
"+ invs[k] = inv",
"+ for m in range(k, 1, -1):",
"+ inv *= m",
"+ inv %= MOD",
"+ invs[m - 1] = inv"
] | false | 0.285918 | 0.056096 | 5.096923 | [
"s774005063",
"s944030791"
] |
u914797917 | p02725 | python | s730884954 | s059947876 | 271 | 118 | 26,444 | 26,060 | Accepted | Accepted | 56.46 | K,N = list(map(int, input().split()))
A=[]
A=list(map(int, input().split()))
D=[]
for i in range(N-1):
D.append(int(A[i+1])-int(A[i]))
D.append(K-int(A[N-1])+int(A[0]))
Dmax=0
Sum=0
for i in range(N):
if int(D[i])>Dmax:
Dmax=int(D[i])
Sum=Sum+int(D[i])
print((Sum-Dmax)) | K,N=list(map(int, input().split()))
A=list(map(int, input().split()))
D=[]
for i in range(1,N):
D.append(A[i]-A[i-1])
D.append(A[0]+K-A[N-1])
print((sum(D)-max(D))) | 20 | 9 | 304 | 168 | K, N = list(map(int, input().split()))
A = []
A = list(map(int, input().split()))
D = []
for i in range(N - 1):
D.append(int(A[i + 1]) - int(A[i]))
D.append(K - int(A[N - 1]) + int(A[0]))
Dmax = 0
Sum = 0
for i in range(N):
if int(D[i]) > Dmax:
Dmax = int(D[i])
Sum = Sum + int(D[i])
print((Sum - Dmax))
| K, N = list(map(int, input().split()))
A = list(map(int, input().split()))
D = []
for i in range(1, N):
D.append(A[i] - A[i - 1])
D.append(A[0] + K - A[N - 1])
print((sum(D) - max(D)))
| false | 55 | [
"-A = []",
"-for i in range(N - 1):",
"- D.append(int(A[i + 1]) - int(A[i]))",
"-D.append(K - int(A[N - 1]) + int(A[0]))",
"-Dmax = 0",
"-Sum = 0",
"-for i in range(N):",
"- if int(D[i]) > Dmax:",
"- Dmax = int(D[i])",
"- Sum = Sum + int(D[i])",
"-print((Sum - Dmax))",
"+for i in range(1, N):",
"+ D.append(A[i] - A[i - 1])",
"+D.append(A[0] + K - A[N - 1])",
"+print((sum(D) - max(D)))"
] | false | 0.036033 | 0.039568 | 0.910668 | [
"s730884954",
"s059947876"
] |
u686230543 | p02662 | python | s161068900 | s809927052 | 323 | 279 | 97,452 | 27,464 | Accepted | Accepted | 13.62 | import numpy as np
mod = 998244353
n, s = list(map(int, input().split()))
dp = np.zeros((n+1, s+1), dtype=int)
dp[0, 0] = 1
for i, a in enumerate(map(int, input().split())):
dp[i+1] = dp[i] * 2 % mod
dp[i+1][a:] = (dp[i+1][a:] + dp[i][:-a]) % mod
print((dp[-1, -1])) | import numpy as np
mod = 998244353
n, s = list(map(int, input().split()))
dp = np.zeros(s+1, dtype=int)
dp[0] = 1
for a in map(int, input().split()):
pre_dp = dp
dp = pre_dp * 2 % mod
dp[a:] = (dp[a:] + pre_dp[:-a]) % mod
print((dp[-1])) | 10 | 11 | 272 | 246 | import numpy as np
mod = 998244353
n, s = list(map(int, input().split()))
dp = np.zeros((n + 1, s + 1), dtype=int)
dp[0, 0] = 1
for i, a in enumerate(map(int, input().split())):
dp[i + 1] = dp[i] * 2 % mod
dp[i + 1][a:] = (dp[i + 1][a:] + dp[i][:-a]) % mod
print((dp[-1, -1]))
| import numpy as np
mod = 998244353
n, s = list(map(int, input().split()))
dp = np.zeros(s + 1, dtype=int)
dp[0] = 1
for a in map(int, input().split()):
pre_dp = dp
dp = pre_dp * 2 % mod
dp[a:] = (dp[a:] + pre_dp[:-a]) % mod
print((dp[-1]))
| false | 9.090909 | [
"-dp = np.zeros((n + 1, s + 1), dtype=int)",
"-dp[0, 0] = 1",
"-for i, a in enumerate(map(int, input().split())):",
"- dp[i + 1] = dp[i] * 2 % mod",
"- dp[i + 1][a:] = (dp[i + 1][a:] + dp[i][:-a]) % mod",
"-print((dp[-1, -1]))",
"+dp = np.zeros(s + 1, dtype=int)",
"+dp[0] = 1",
"+for a in map(int, input().split()):",
"+ pre_dp = dp",
"+ dp = pre_dp * 2 % mod",
"+ dp[a:] = (dp[a:] + pre_dp[:-a]) % mod",
"+print((dp[-1]))"
] | false | 0.240996 | 0.250379 | 0.962525 | [
"s161068900",
"s809927052"
] |
u061916079 | p03986 | python | s792416259 | s087725242 | 227 | 83 | 14,436 | 3,500 | Accepted | Accepted | 63.44 | # -*- coding: utf-8 -*-
import math
import sys
import itertools
import numpy as np
import functools
import collections
mo = 1000000007
r = range
s = eval(input())
ret = 0
tmp = 0
for c in s:
tmp += 1 if c == 'S' else -1
ret = min(ret, tmp)
print((-ret*2)) | s = eval(input())
ret = 0
tmp = 0
for c in s:
tmp += 1 if c == 'S' else -1
ret = min(ret, tmp)
print((-ret*2)) | 18 | 8 | 274 | 118 | # -*- coding: utf-8 -*-
import math
import sys
import itertools
import numpy as np
import functools
import collections
mo = 1000000007
r = range
s = eval(input())
ret = 0
tmp = 0
for c in s:
tmp += 1 if c == "S" else -1
ret = min(ret, tmp)
print((-ret * 2))
| s = eval(input())
ret = 0
tmp = 0
for c in s:
tmp += 1 if c == "S" else -1
ret = min(ret, tmp)
print((-ret * 2))
| false | 55.555556 | [
"-# -*- coding: utf-8 -*-",
"-import math",
"-import sys",
"-import itertools",
"-import numpy as np",
"-import functools",
"-import collections",
"-",
"-mo = 1000000007",
"-r = range"
] | false | 0.036327 | 0.040741 | 0.891662 | [
"s792416259",
"s087725242"
] |
u700805562 | p02597 | python | s727713400 | s116581402 | 33 | 30 | 9,228 | 9,268 | Accepted | Accepted | 9.09 | n,c=eval(input()),eval(input());print((c[:c.count('R')].count('W'))) | i=input;n,c=i(),i();print((c[:c.count('R')].count('W'))) | 1 | 1 | 54 | 54 | n, c = eval(input()), eval(input())
print((c[: c.count("R")].count("W")))
| i = input
n, c = i(), i()
print((c[: c.count("R")].count("W")))
| false | 0 | [
"-n, c = eval(input()), eval(input())",
"+i = input",
"+n, c = i(), i()"
] | false | 0.04236 | 0.040142 | 1.05525 | [
"s727713400",
"s116581402"
] |
u618306958 | p02713 | python | s126940161 | s955080478 | 478 | 59 | 68,856 | 62,492 | Accepted | Accepted | 87.66 | import math
k = int(eval(input()))
sum = 0
for i in range(1,k+1):
for j in range(1,k+1):
for l in range(1,k+1):
sum+=math.gcd(math.gcd(i,j),l)
print(sum) | k = int(eval(input()))
arr = [0]*(k+1)
count = [0]*(k+1)
sum = 0
n = 3
for i in range(k,1,-1):
x = k//i
p = int(pow(x,n))
arr[i]=i*p
count[i]=p
for j in range(x-1):
arr[i]-=i*count[i*(j+2)]
count[i]-=count[i*(j+2)]
csum = 0
for i in range(2,k+1):
sum+=arr[i]
csum+=count[i]
sum+=(int(pow(k,n)) - csum)
print((int(sum%(1e9+7))))
| 8 | 20 | 178 | 386 | import math
k = int(eval(input()))
sum = 0
for i in range(1, k + 1):
for j in range(1, k + 1):
for l in range(1, k + 1):
sum += math.gcd(math.gcd(i, j), l)
print(sum)
| k = int(eval(input()))
arr = [0] * (k + 1)
count = [0] * (k + 1)
sum = 0
n = 3
for i in range(k, 1, -1):
x = k // i
p = int(pow(x, n))
arr[i] = i * p
count[i] = p
for j in range(x - 1):
arr[i] -= i * count[i * (j + 2)]
count[i] -= count[i * (j + 2)]
csum = 0
for i in range(2, k + 1):
sum += arr[i]
csum += count[i]
sum += int(pow(k, n)) - csum
print((int(sum % (1e9 + 7))))
| false | 60 | [
"-import math",
"-",
"+arr = [0] * (k + 1)",
"+count = [0] * (k + 1)",
"-for i in range(1, k + 1):",
"- for j in range(1, k + 1):",
"- for l in range(1, k + 1):",
"- sum += math.gcd(math.gcd(i, j), l)",
"-print(sum)",
"+n = 3",
"+for i in range(k, 1, -1):",
"+ x = k // i",
"+ p = int(pow(x, n))",
"+ arr[i] = i * p",
"+ count[i] = p",
"+ for j in range(x - 1):",
"+ arr[i] -= i * count[i * (j + 2)]",
"+ count[i] -= count[i * (j + 2)]",
"+csum = 0",
"+for i in range(2, k + 1):",
"+ sum += arr[i]",
"+ csum += count[i]",
"+sum += int(pow(k, n)) - csum",
"+print((int(sum % (1e9 + 7))))"
] | false | 0.061853 | 0.036621 | 1.688982 | [
"s126940161",
"s955080478"
] |
u394482932 | p03813 | python | s899831238 | s903833316 | 162 | 17 | 38,256 | 2,940 | Accepted | Accepted | 89.51 | print(("AARBCC"[1200>int(eval(input()))::2])) | print(("AARBCC"["1200">eval(input())::2])) | 1 | 1 | 37 | 34 | print(("AARBCC"[1200 > int(eval(input())) :: 2]))
| print(("AARBCC"["1200" > eval(input()) :: 2]))
| false | 0 | [
"-print((\"AARBCC\"[1200 > int(eval(input())) :: 2]))",
"+print((\"AARBCC\"[\"1200\" > eval(input()) :: 2]))"
] | false | 0.110763 | 0.108096 | 1.024672 | [
"s899831238",
"s903833316"
] |
u977389981 | p03212 | python | s023681201 | s444616340 | 930 | 92 | 4,072 | 4,060 | Accepted | Accepted | 90.11 | N = int(eval(input()))
A = []
def f(s):
if s != '' and eval(s) > N:
return 0
if all(s.count(i) >= 1 for i in '753'):
A.append(eval(s))
for i in '753':
f(s + i)
f('')
print((len(A)))
# print(sorted(A)) | N = int(eval(input()))
A = []
def f(s):
if int(s) > N:
return 0
if all(s.count(i) >= 1 for i in '753'):
A.append(int(s))
for i in '753':
f(s + i)
f('0')
print((len(A)))
# print(sorted(A)) | 14 | 14 | 243 | 230 | N = int(eval(input()))
A = []
def f(s):
if s != "" and eval(s) > N:
return 0
if all(s.count(i) >= 1 for i in "753"):
A.append(eval(s))
for i in "753":
f(s + i)
f("")
print((len(A)))
# print(sorted(A))
| N = int(eval(input()))
A = []
def f(s):
if int(s) > N:
return 0
if all(s.count(i) >= 1 for i in "753"):
A.append(int(s))
for i in "753":
f(s + i)
f("0")
print((len(A)))
# print(sorted(A))
| false | 0 | [
"- if s != \"\" and eval(s) > N:",
"+ if int(s) > N:",
"- A.append(eval(s))",
"+ A.append(int(s))",
"-f(\"\")",
"+f(\"0\")"
] | false | 0.496378 | 0.06006 | 8.264665 | [
"s023681201",
"s444616340"
] |
u075303794 | p02928 | python | s166915315 | s668695446 | 860 | 29 | 3,316 | 3,564 | Accepted | Accepted | 96.63 | N,K = list(map(int,input().split()))
A = list(map(int,input().split()*2))
base1 = 0
base2 = 0
for i in range(N):
count1=0
count2=0
for j in range(i+1,i+N+1):
if A[i] > A[j]:
if j < N:
count1+=1
else:
count2+=1
base1+=count1
base2+=count2
ans = (base1*K*(K+1) + base2*K*(K-1))//2
div = 10**9 + 7
print((ans%div)) | from collections import Counter
class Bit:
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.tree[i] += x
i += i & -i
n,k = list(map(int, input().split()))
aaa = list(map(int, input().split()))
MOD = 10**9 + 7
bit = Bit(2001)
single = 0
for a in reversed(aaa):
single += bit.sum(a)
bit.add(a + 1, 1)
ans = single * k % MOD
coef = k * (k - 1) // 2 % MOD
cnt = Counter(aaa)
before = 0
for a, c in sorted(cnt.items()):
ans = (ans + c * before * coef) % MOD
before += c
print(ans)
| 19 | 39 | 364 | 720 | N, K = list(map(int, input().split()))
A = list(map(int, input().split() * 2))
base1 = 0
base2 = 0
for i in range(N):
count1 = 0
count2 = 0
for j in range(i + 1, i + N + 1):
if A[i] > A[j]:
if j < N:
count1 += 1
else:
count2 += 1
base1 += count1
base2 += count2
ans = (base1 * K * (K + 1) + base2 * K * (K - 1)) // 2
div = 10**9 + 7
print((ans % div))
| from collections import Counter
class Bit:
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.tree[i] += x
i += i & -i
n, k = list(map(int, input().split()))
aaa = list(map(int, input().split()))
MOD = 10**9 + 7
bit = Bit(2001)
single = 0
for a in reversed(aaa):
single += bit.sum(a)
bit.add(a + 1, 1)
ans = single * k % MOD
coef = k * (k - 1) // 2 % MOD
cnt = Counter(aaa)
before = 0
for a, c in sorted(cnt.items()):
ans = (ans + c * before * coef) % MOD
before += c
print(ans)
| false | 51.282051 | [
"-N, K = list(map(int, input().split()))",
"-A = list(map(int, input().split() * 2))",
"-base1 = 0",
"-base2 = 0",
"-for i in range(N):",
"- count1 = 0",
"- count2 = 0",
"- for j in range(i + 1, i + N + 1):",
"- if A[i] > A[j]:",
"- if j < N:",
"- count1 += 1",
"- else:",
"- count2 += 1",
"- base1 += count1",
"- base2 += count2",
"-ans = (base1 * K * (K + 1) + base2 * K * (K - 1)) // 2",
"-div = 10**9 + 7",
"-print((ans % div))",
"+from collections import Counter",
"+",
"+",
"+class Bit:",
"+ def __init__(self, n):",
"+ self.size = n",
"+ self.tree = [0] * (n + 1)",
"+",
"+ def sum(self, i):",
"+ s = 0",
"+ while i > 0:",
"+ s += self.tree[i]",
"+ i -= i & -i",
"+ return s",
"+",
"+ def add(self, i, x):",
"+ while i <= self.size:",
"+ self.tree[i] += x",
"+ i += i & -i",
"+",
"+",
"+n, k = list(map(int, input().split()))",
"+aaa = list(map(int, input().split()))",
"+MOD = 10**9 + 7",
"+bit = Bit(2001)",
"+single = 0",
"+for a in reversed(aaa):",
"+ single += bit.sum(a)",
"+ bit.add(a + 1, 1)",
"+ans = single * k % MOD",
"+coef = k * (k - 1) // 2 % MOD",
"+cnt = Counter(aaa)",
"+before = 0",
"+for a, c in sorted(cnt.items()):",
"+ ans = (ans + c * before * coef) % MOD",
"+ before += c",
"+print(ans)"
] | false | 0.103812 | 0.040175 | 2.584007 | [
"s166915315",
"s668695446"
] |
u905203728 | p02631 | python | s453316098 | s162885038 | 298 | 189 | 50,068 | 105,612 | Accepted | Accepted | 36.58 | import numpy as np
n=int(eval(input()))
A=list(map(int,input().split()))
C=A
A=np.array(A)
length=len(format(max(A),"b"))
B=""
for i in range(length):
cnt=np.count_nonzero(A&1)
if cnt%2==0:B +="0"
else:B +="1"
A >>=1
B=int(B[::-1],2)
D=[]
for i in C:
D.append(B^i)
print((*D)) | n=int(input())
A=list(map(int,input().split()))
num=0
for i in A:num ^=i
for i in A:print(num^i,end=" ")
| 19 | 6 | 308 | 110 | import numpy as np
n = int(eval(input()))
A = list(map(int, input().split()))
C = A
A = np.array(A)
length = len(format(max(A), "b"))
B = ""
for i in range(length):
cnt = np.count_nonzero(A & 1)
if cnt % 2 == 0:
B += "0"
else:
B += "1"
A >>= 1
B = int(B[::-1], 2)
D = []
for i in C:
D.append(B ^ i)
print((*D))
| n = int(input())
A = list(map(int, input().split()))
num = 0
for i in A:
num ^= i
for i in A:
print(num ^ i, end=" ")
| false | 68.421053 | [
"-import numpy as np",
"-",
"-n = int(eval(input()))",
"+n = int(input())",
"-C = A",
"-A = np.array(A)",
"-length = len(format(max(A), \"b\"))",
"-B = \"\"",
"-for i in range(length):",
"- cnt = np.count_nonzero(A & 1)",
"- if cnt % 2 == 0:",
"- B += \"0\"",
"- else:",
"- B += \"1\"",
"- A >>= 1",
"-B = int(B[::-1], 2)",
"-D = []",
"-for i in C:",
"- D.append(B ^ i)",
"-print((*D))",
"+num = 0",
"+for i in A:",
"+ num ^= i",
"+for i in A:",
"+ print(num ^ i, end=\" \")"
] | false | 0.198635 | 0.036848 | 5.390641 | [
"s453316098",
"s162885038"
] |
u017810624 | p03660 | python | s873482695 | s762636296 | 733 | 440 | 82,388 | 77,656 | Accepted | Accepted | 39.97 | def bfs(v):
distance=[-1]*n
distance[v]=0
next=connection[v]
next2=set()
visited=[-1]*n
visited[v]=1
visitct=1
ct=0
while visitct!=n:
ct+=1
for i in range(len(next)):
distance[next[i]]=ct
visited[next[i]]=1
visitct+=1
for j in range(len(connection[next[i]])):
if visited[connection[next[i]][j]]==-1:
next2.add(connection[next[i]][j])
next=list(next2)
next2=set()
return distance
n=int(eval(input()))
l=[list(map(int,input().split())) for i in range(n-1)]
connection=[[] for i in range(n)]
for i in range(n-1):
connection[l[i][0]-1].append(l[i][1]-1)
connection[l[i][1]-1].append(l[i][0]-1)
f=bfs(0);s=bfs(n-1)
ctf=0;cts=0
for i in range(n):
if f[i]<=s[i]:
ctf+=1
else:
cts+=1
if ctf>cts:
print('Fennec')
else:
print('Snuke') | def bfs(v):
distance=[-1]*n
distance[v]=0
next=connection[v]
next2=set()
visited=[-1]*n
visited[v]=1
visitct=1
ct=0
while visitct!=n:
ct+=1
for i in range(len(next)):
distance[next[i]]=ct
visited[next[i]]=1
visitct+=1
for j in range(len(connection[next[i]])):
if visited[connection[next[i]][j]]==-1:
next2.add(connection[next[i]][j])
next=list(next2)
next2=set()
return distance
import sys
input = sys.stdin.readline
n=int(eval(input()))
l=[list(map(int,input().split())) for i in range(n-1)]
connection=[[] for i in range(n)]
for i in range(n-1):
connection[l[i][0]-1].append(l[i][1]-1)
connection[l[i][1]-1].append(l[i][0]-1)
f=bfs(0);s=bfs(n-1)
ctf=0;cts=0
for i in range(n):
if f[i]<=s[i]:
ctf+=1
else:
cts+=1
if ctf>cts:
print('Fennec')
else:
print('Snuke') | 42 | 44 | 865 | 905 | def bfs(v):
distance = [-1] * n
distance[v] = 0
next = connection[v]
next2 = set()
visited = [-1] * n
visited[v] = 1
visitct = 1
ct = 0
while visitct != n:
ct += 1
for i in range(len(next)):
distance[next[i]] = ct
visited[next[i]] = 1
visitct += 1
for j in range(len(connection[next[i]])):
if visited[connection[next[i]][j]] == -1:
next2.add(connection[next[i]][j])
next = list(next2)
next2 = set()
return distance
n = int(eval(input()))
l = [list(map(int, input().split())) for i in range(n - 1)]
connection = [[] for i in range(n)]
for i in range(n - 1):
connection[l[i][0] - 1].append(l[i][1] - 1)
connection[l[i][1] - 1].append(l[i][0] - 1)
f = bfs(0)
s = bfs(n - 1)
ctf = 0
cts = 0
for i in range(n):
if f[i] <= s[i]:
ctf += 1
else:
cts += 1
if ctf > cts:
print("Fennec")
else:
print("Snuke")
| def bfs(v):
distance = [-1] * n
distance[v] = 0
next = connection[v]
next2 = set()
visited = [-1] * n
visited[v] = 1
visitct = 1
ct = 0
while visitct != n:
ct += 1
for i in range(len(next)):
distance[next[i]] = ct
visited[next[i]] = 1
visitct += 1
for j in range(len(connection[next[i]])):
if visited[connection[next[i]][j]] == -1:
next2.add(connection[next[i]][j])
next = list(next2)
next2 = set()
return distance
import sys
input = sys.stdin.readline
n = int(eval(input()))
l = [list(map(int, input().split())) for i in range(n - 1)]
connection = [[] for i in range(n)]
for i in range(n - 1):
connection[l[i][0] - 1].append(l[i][1] - 1)
connection[l[i][1] - 1].append(l[i][0] - 1)
f = bfs(0)
s = bfs(n - 1)
ctf = 0
cts = 0
for i in range(n):
if f[i] <= s[i]:
ctf += 1
else:
cts += 1
if ctf > cts:
print("Fennec")
else:
print("Snuke")
| false | 4.545455 | [
"+import sys",
"+",
"+input = sys.stdin.readline"
] | false | 0.045401 | 0.04468 | 1.016126 | [
"s873482695",
"s762636296"
] |
u533883485 | p02271 | python | s919755875 | s611322200 | 6,350 | 20 | 7,952 | 8,024 | Accepted | Accepted | 99.69 | # coding=utf-8
def solve(i, m):
global A
if m == 0:
ever_calc[i][m] = True
return True
elif m < 0:
ever_calc[i][m] = False
return False
elif i == n:
ever_calc[i][m] = False
return False
else:
result = (solve(i+1, m) or solve(i+1, m-A[i]))
ever_calc[i][m] = result
return result
n = int(eval(input()))
A = tuple(map(int, input().split()))
q = int(eval(input()))
M = tuple(map(int, input().split()))
sum_A = sum(A)
ever_calc = [[None] * 2000 for i in range(n+1)]
for m in M:
if m > sum_A:
print('no')
elif solve(0, m):
print('yes')
else:
print('no') | # coding=utf-8
def solve(i, m):
global A
if ever_calc[i][m] != None:
return ever_calc[i][m]
if m == 0:
ever_calc[i][m] = True
return True
elif m < 0:
ever_calc[i][m] = False
return False
elif i == n:
ever_calc[i][m] = False
return False
else:
result = (solve(i+1, m) or solve(i+1, m-A[i]))
ever_calc[i][m] = result
return result
n = int(eval(input()))
A = tuple(map(int, input().split()))
q = int(eval(input()))
M = tuple(map(int, input().split()))
sum_A = sum(A)
ever_calc = [[None] * 2000 for i in range(n+1)]
for m in M:
if m > sum_A:
print('no')
elif solve(0, m):
print('yes')
else:
print('no') | 32 | 34 | 697 | 762 | # coding=utf-8
def solve(i, m):
global A
if m == 0:
ever_calc[i][m] = True
return True
elif m < 0:
ever_calc[i][m] = False
return False
elif i == n:
ever_calc[i][m] = False
return False
else:
result = solve(i + 1, m) or solve(i + 1, m - A[i])
ever_calc[i][m] = result
return result
n = int(eval(input()))
A = tuple(map(int, input().split()))
q = int(eval(input()))
M = tuple(map(int, input().split()))
sum_A = sum(A)
ever_calc = [[None] * 2000 for i in range(n + 1)]
for m in M:
if m > sum_A:
print("no")
elif solve(0, m):
print("yes")
else:
print("no")
| # coding=utf-8
def solve(i, m):
global A
if ever_calc[i][m] != None:
return ever_calc[i][m]
if m == 0:
ever_calc[i][m] = True
return True
elif m < 0:
ever_calc[i][m] = False
return False
elif i == n:
ever_calc[i][m] = False
return False
else:
result = solve(i + 1, m) or solve(i + 1, m - A[i])
ever_calc[i][m] = result
return result
n = int(eval(input()))
A = tuple(map(int, input().split()))
q = int(eval(input()))
M = tuple(map(int, input().split()))
sum_A = sum(A)
ever_calc = [[None] * 2000 for i in range(n + 1)]
for m in M:
if m > sum_A:
print("no")
elif solve(0, m):
print("yes")
else:
print("no")
| false | 5.882353 | [
"+ if ever_calc[i][m] != None:",
"+ return ever_calc[i][m]"
] | false | 0.051629 | 0.050507 | 1.0222 | [
"s919755875",
"s611322200"
] |
u201234972 | p03331 | python | s462584019 | s725742665 | 436 | 17 | 2,940 | 3,060 | Accepted | Accepted | 96.1 | def kakuwa(S):
A = list(str(S))
B = [int(x) for x in A]
return sum(B)
N = int(eval(input()))
ans = 50
for i in range(1,N):
ans = min(ans, kakuwa(i) + kakuwa(N-i))
print(ans) | def kakuwa(S):
A = list(str(S))
B = [int(x) for x in A]
return sum(B)
N = int(eval(input()))
for i in range(1,5):
if N%(10**i) == 0:
ans = 10
break
else:
ans = kakuwa(N)
print(ans) | 10 | 13 | 197 | 227 | def kakuwa(S):
A = list(str(S))
B = [int(x) for x in A]
return sum(B)
N = int(eval(input()))
ans = 50
for i in range(1, N):
ans = min(ans, kakuwa(i) + kakuwa(N - i))
print(ans)
| def kakuwa(S):
A = list(str(S))
B = [int(x) for x in A]
return sum(B)
N = int(eval(input()))
for i in range(1, 5):
if N % (10**i) == 0:
ans = 10
break
else:
ans = kakuwa(N)
print(ans)
| false | 23.076923 | [
"-ans = 50",
"-for i in range(1, N):",
"- ans = min(ans, kakuwa(i) + kakuwa(N - i))",
"+for i in range(1, 5):",
"+ if N % (10**i) == 0:",
"+ ans = 10",
"+ break",
"+else:",
"+ ans = kakuwa(N)"
] | false | 0.248556 | 0.036999 | 6.717829 | [
"s462584019",
"s725742665"
] |
u729133443 | p04048 | python | s755419303 | s830726603 | 263 | 20 | 64,620 | 9,164 | Accepted | Accepted | 92.4 | from fractions import*
n,x=list(map(int,input().split()))
print((3*(n-gcd(n,x)))) | import math
n,x=list(map(int,input().split()))
print((3*(n-math.gcd(n,x)))) | 3 | 3 | 75 | 69 | from fractions import *
n, x = list(map(int, input().split()))
print((3 * (n - gcd(n, x))))
| import math
n, x = list(map(int, input().split()))
print((3 * (n - math.gcd(n, x))))
| false | 0 | [
"-from fractions import *",
"+import math",
"-print((3 * (n - gcd(n, x))))",
"+print((3 * (n - math.gcd(n, x))))"
] | false | 0.166344 | 0.036022 | 4.61791 | [
"s755419303",
"s830726603"
] |
u945200821 | p02713 | python | s088503553 | s051681144 | 963 | 338 | 143,128 | 26,936 | Accepted | Accepted | 64.9 | import math
from typing import List, NoReturn
def sum_gcd(k: int) -> int:
cache: List[List[List[int]]] = [[[0] * (k + 1) for i in range(k + 1)] for j in range(k + 1)]
def cached_gcd(a: int, b: int, c: int) -> int:
k0: int
k1: int
k2: int
k0, k1, k2 = sorted([a, b, c])
result: int = cache[k0][k1][k2]
if result > 0:
return result
else:
result = math.gcd(math.gcd(k0, k1), k2)
cache[k0][k1][k2] = result
return result
answer: int = 0
for h in range(1, k + 1):
for i in range(1, k + 1):
for j in range(1, k + 1):
answer += cached_gcd(h, i, j)
return answer
def main() -> NoReturn:
k: int = int(input().rstrip())
print((sum_gcd(k)))
if __name__ == '__main__':
main()
| from math import gcd
import numpy as np
def sum_gcd(k: int) -> int:
# a > b > c
sum_p1 = 0
for h in range(1, k + 1):
for i in range(1, h):
for j in range(1, i):
sum_p1 += gcd(gcd(h, i), j)
# a = b > c and a > b = c
sum_p2 = 0
for h in range(1, k + 1):
for i in range(1, h):
sum_p2 += gcd(h, i)
# a = b = c
sum_p3 = k * (k + 1) //2
answer = sum_p1 * 6 + sum_p2 * 6 + sum_p3
return answer
def main():
k = int(input().rstrip())
print((sum_gcd(k)))
if __name__ == '__main__':
main()
| 37 | 34 | 880 | 649 | import math
from typing import List, NoReturn
def sum_gcd(k: int) -> int:
cache: List[List[List[int]]] = [
[[0] * (k + 1) for i in range(k + 1)] for j in range(k + 1)
]
def cached_gcd(a: int, b: int, c: int) -> int:
k0: int
k1: int
k2: int
k0, k1, k2 = sorted([a, b, c])
result: int = cache[k0][k1][k2]
if result > 0:
return result
else:
result = math.gcd(math.gcd(k0, k1), k2)
cache[k0][k1][k2] = result
return result
answer: int = 0
for h in range(1, k + 1):
for i in range(1, k + 1):
for j in range(1, k + 1):
answer += cached_gcd(h, i, j)
return answer
def main() -> NoReturn:
k: int = int(input().rstrip())
print((sum_gcd(k)))
if __name__ == "__main__":
main()
| from math import gcd
import numpy as np
def sum_gcd(k: int) -> int:
# a > b > c
sum_p1 = 0
for h in range(1, k + 1):
for i in range(1, h):
for j in range(1, i):
sum_p1 += gcd(gcd(h, i), j)
# a = b > c and a > b = c
sum_p2 = 0
for h in range(1, k + 1):
for i in range(1, h):
sum_p2 += gcd(h, i)
# a = b = c
sum_p3 = k * (k + 1) // 2
answer = sum_p1 * 6 + sum_p2 * 6 + sum_p3
return answer
def main():
k = int(input().rstrip())
print((sum_gcd(k)))
if __name__ == "__main__":
main()
| false | 8.108108 | [
"-import math",
"-from typing import List, NoReturn",
"+from math import gcd",
"+import numpy as np",
"- cache: List[List[List[int]]] = [",
"- [[0] * (k + 1) for i in range(k + 1)] for j in range(k + 1)",
"- ]",
"-",
"- def cached_gcd(a: int, b: int, c: int) -> int:",
"- k0: int",
"- k1: int",
"- k2: int",
"- k0, k1, k2 = sorted([a, b, c])",
"- result: int = cache[k0][k1][k2]",
"- if result > 0:",
"- return result",
"- else:",
"- result = math.gcd(math.gcd(k0, k1), k2)",
"- cache[k0][k1][k2] = result",
"- return result",
"-",
"- answer: int = 0",
"+ # a > b > c",
"+ sum_p1 = 0",
"- for i in range(1, k + 1):",
"- for j in range(1, k + 1):",
"- answer += cached_gcd(h, i, j)",
"+ for i in range(1, h):",
"+ for j in range(1, i):",
"+ sum_p1 += gcd(gcd(h, i), j)",
"+ # a = b > c and a > b = c",
"+ sum_p2 = 0",
"+ for h in range(1, k + 1):",
"+ for i in range(1, h):",
"+ sum_p2 += gcd(h, i)",
"+ # a = b = c",
"+ sum_p3 = k * (k + 1) // 2",
"+ answer = sum_p1 * 6 + sum_p2 * 6 + sum_p3",
"-def main() -> NoReturn:",
"- k: int = int(input().rstrip())",
"+def main():",
"+ k = int(input().rstrip())"
] | false | 0.047881 | 0.047504 | 1.007942 | [
"s088503553",
"s051681144"
] |
u627803856 | p02613 | python | s981134002 | s305688548 | 200 | 163 | 79,512 | 74,456 | Accepted | Accepted | 18.5 | n = int(eval(input()))
s = [eval(input()) for _ in range(n)]
from collections import Counter
c = Counter(s)
if 'AC' in list(c.keys()):
print(('AC x', c['AC']))
else:
print('AC x 0')
if 'WA' in list(c.keys()):
print(('WA x', c['WA']))
else:
print('WA x 0')
if 'TLE' in list(c.keys()):
print(('TLE x', c['TLE']))
else:
print('TLE x 0')
if 'RE' in list(c.keys()):
print(('RE x', c['RE']))
else:
print('RE x 0')
| from collections import defaultdict
n = int(eval(input()))
d = defaultdict(int)
for i in range(n):
d[eval(input())] += 1
for v in ['AC', 'WA', 'TLE', 'RE']:
print((v, 'x', d[v])) | 21 | 7 | 417 | 178 | n = int(eval(input()))
s = [eval(input()) for _ in range(n)]
from collections import Counter
c = Counter(s)
if "AC" in list(c.keys()):
print(("AC x", c["AC"]))
else:
print("AC x 0")
if "WA" in list(c.keys()):
print(("WA x", c["WA"]))
else:
print("WA x 0")
if "TLE" in list(c.keys()):
print(("TLE x", c["TLE"]))
else:
print("TLE x 0")
if "RE" in list(c.keys()):
print(("RE x", c["RE"]))
else:
print("RE x 0")
| from collections import defaultdict
n = int(eval(input()))
d = defaultdict(int)
for i in range(n):
d[eval(input())] += 1
for v in ["AC", "WA", "TLE", "RE"]:
print((v, "x", d[v]))
| false | 66.666667 | [
"+from collections import defaultdict",
"+",
"-s = [eval(input()) for _ in range(n)]",
"-from collections import Counter",
"-",
"-c = Counter(s)",
"-if \"AC\" in list(c.keys()):",
"- print((\"AC x\", c[\"AC\"]))",
"-else:",
"- print(\"AC x 0\")",
"-if \"WA\" in list(c.keys()):",
"- print((\"WA x\", c[\"WA\"]))",
"-else:",
"- print(\"WA x 0\")",
"-if \"TLE\" in list(c.keys()):",
"- print((\"TLE x\", c[\"TLE\"]))",
"-else:",
"- print(\"TLE x 0\")",
"-if \"RE\" in list(c.keys()):",
"- print((\"RE x\", c[\"RE\"]))",
"-else:",
"- print(\"RE x 0\")",
"+d = defaultdict(int)",
"+for i in range(n):",
"+ d[eval(input())] += 1",
"+for v in [\"AC\", \"WA\", \"TLE\", \"RE\"]:",
"+ print((v, \"x\", d[v]))"
] | false | 0.124678 | 0.079 | 1.578192 | [
"s981134002",
"s305688548"
] |
u028973125 | p02837 | python | s191068161 | s566498760 | 298 | 237 | 45,164 | 44,140 | Accepted | Accepted | 20.47 | import sys
from pprint import pprint
def solve(n, info):
ans = 0
for i in range(2 ** n):
true_info = {}
p_info = [0] * n
for j in range(n):
if (i >> j) & 1:
true_info[j] = info[j]
for x, y in info[j]:
if y == 1:
true_info[x-1] = info[x-1]
# pprint(info[j])
p_info[j] = 1
# print("p_info")
# pprint(p_info)
# print("true_info")
# pprint(true_info)
flag = True
for _, info_list in list(true_info.items()):
for x, y in info_list:
if p_info[x-1] != y:
flag = False
break
if not flag:
break
if flag:
# pprint(true_info)
ans = max(ans, sum(p_info))
print(ans)
if __name__ == '__main__':
n = int(sys.stdin.readline().strip())
info = []
for i in range(n):
a = int(sys.stdin.readline().strip())
info.append([])
for _ in range(a):
x, y = list(map(int, sys.stdin.readline().strip().split(" ")))
info[i].append((x, y))
# pprint(info)
solve(n, info) | import sys
from pprint import pprint
def solve(n, info):
ans = 0
for i in range(2 ** n):
true_info = {}
p_info = [0] * n
for j in range(n):
if (i >> j) & 1:
true_info[j] = info[j]
# pprint(info[j])
p_info[j] = 1
# print("p_info")
# pprint(p_info)
# print("true_info")
# pprint(true_info)
flag = True
for _, info_list in list(true_info.items()):
for x, y in info_list:
if p_info[x-1] != y:
flag = False
break
if not flag:
break
if flag:
# pprint(true_info)
ans = max(ans, sum(p_info))
print(ans)
if __name__ == '__main__':
n = int(sys.stdin.readline().strip())
info = []
for i in range(n):
a = int(sys.stdin.readline().strip())
info.append([])
for _ in range(a):
x, y = list(map(int, sys.stdin.readline().strip().split(" ")))
info[i].append((x, y))
# pprint(info)
solve(n, info) | 47 | 44 | 1,279 | 1,157 | import sys
from pprint import pprint
def solve(n, info):
ans = 0
for i in range(2**n):
true_info = {}
p_info = [0] * n
for j in range(n):
if (i >> j) & 1:
true_info[j] = info[j]
for x, y in info[j]:
if y == 1:
true_info[x - 1] = info[x - 1]
# pprint(info[j])
p_info[j] = 1
# print("p_info")
# pprint(p_info)
# print("true_info")
# pprint(true_info)
flag = True
for _, info_list in list(true_info.items()):
for x, y in info_list:
if p_info[x - 1] != y:
flag = False
break
if not flag:
break
if flag:
# pprint(true_info)
ans = max(ans, sum(p_info))
print(ans)
if __name__ == "__main__":
n = int(sys.stdin.readline().strip())
info = []
for i in range(n):
a = int(sys.stdin.readline().strip())
info.append([])
for _ in range(a):
x, y = list(map(int, sys.stdin.readline().strip().split(" ")))
info[i].append((x, y))
# pprint(info)
solve(n, info)
| import sys
from pprint import pprint
def solve(n, info):
ans = 0
for i in range(2**n):
true_info = {}
p_info = [0] * n
for j in range(n):
if (i >> j) & 1:
true_info[j] = info[j]
# pprint(info[j])
p_info[j] = 1
# print("p_info")
# pprint(p_info)
# print("true_info")
# pprint(true_info)
flag = True
for _, info_list in list(true_info.items()):
for x, y in info_list:
if p_info[x - 1] != y:
flag = False
break
if not flag:
break
if flag:
# pprint(true_info)
ans = max(ans, sum(p_info))
print(ans)
if __name__ == "__main__":
n = int(sys.stdin.readline().strip())
info = []
for i in range(n):
a = int(sys.stdin.readline().strip())
info.append([])
for _ in range(a):
x, y = list(map(int, sys.stdin.readline().strip().split(" ")))
info[i].append((x, y))
# pprint(info)
solve(n, info)
| false | 6.382979 | [
"- for x, y in info[j]:",
"- if y == 1:",
"- true_info[x - 1] = info[x - 1]"
] | false | 0.043396 | 0.041334 | 1.049889 | [
"s191068161",
"s566498760"
] |
u314050667 | p02688 | python | s742101004 | s097557123 | 58 | 21 | 67,856 | 9,168 | Accepted | Accepted | 63.79 | N, K = list(map(int, input().split()))
q = set([])
for _ in range(K):
d = int(eval(input()))
tmp = list(map(int, input().split()))
for i in range(d):
q.add(tmp[i])
ans = N - len(q)
print(ans) | N, K = list(map(int, input().split()))
q = set([])
for _ in range(K):
tmp = int(eval(input()))
A = list(map(int, input().split()))
for a in A:
q.add(a)
print((N - len(q))) | 11 | 9 | 211 | 186 | N, K = list(map(int, input().split()))
q = set([])
for _ in range(K):
d = int(eval(input()))
tmp = list(map(int, input().split()))
for i in range(d):
q.add(tmp[i])
ans = N - len(q)
print(ans)
| N, K = list(map(int, input().split()))
q = set([])
for _ in range(K):
tmp = int(eval(input()))
A = list(map(int, input().split()))
for a in A:
q.add(a)
print((N - len(q)))
| false | 18.181818 | [
"- d = int(eval(input()))",
"- tmp = list(map(int, input().split()))",
"- for i in range(d):",
"- q.add(tmp[i])",
"-ans = N - len(q)",
"-print(ans)",
"+ tmp = int(eval(input()))",
"+ A = list(map(int, input().split()))",
"+ for a in A:",
"+ q.add(a)",
"+print((N - len(q)))"
] | false | 0.038847 | 0.035899 | 1.082116 | [
"s742101004",
"s097557123"
] |
u729133443 | p03128 | python | s509102132 | s893478407 | 206 | 164 | 14,444 | 15,268 | Accepted | Accepted | 20.39 | n,m,*a=list(map(int,open(0).read().split()))
d=[0]*-~n
for i in range(1,n+1):
for j,k in zip(list(range(9)),(2,5,5,4,5,6,3,7,6)):
if i-k>=0and(i-k<1or d[i-k])and j+1in a:d[i]=max(d[i],d[i-k]*10+j+1)
print((d[n])) | n,m,*a=list(map(int,open(0).read().split()))
c=(0,2,5,5,4,5,6,3,7,6)
d=[0]+[-1]*n*9
for i in range(n):
for j in a:
if d[i]>=0:d[i+c[j]]=max(d[i+c[j]],d[i]*10+j)
print((d[n])) | 6 | 7 | 206 | 175 | n, m, *a = list(map(int, open(0).read().split()))
d = [0] * -~n
for i in range(1, n + 1):
for j, k in zip(list(range(9)), (2, 5, 5, 4, 5, 6, 3, 7, 6)):
if i - k >= 0 and (i - k < 1 or d[i - k]) and j + 1 in a:
d[i] = max(d[i], d[i - k] * 10 + j + 1)
print((d[n]))
| n, m, *a = list(map(int, open(0).read().split()))
c = (0, 2, 5, 5, 4, 5, 6, 3, 7, 6)
d = [0] + [-1] * n * 9
for i in range(n):
for j in a:
if d[i] >= 0:
d[i + c[j]] = max(d[i + c[j]], d[i] * 10 + j)
print((d[n]))
| false | 14.285714 | [
"-d = [0] * -~n",
"-for i in range(1, n + 1):",
"- for j, k in zip(list(range(9)), (2, 5, 5, 4, 5, 6, 3, 7, 6)):",
"- if i - k >= 0 and (i - k < 1 or d[i - k]) and j + 1 in a:",
"- d[i] = max(d[i], d[i - k] * 10 + j + 1)",
"+c = (0, 2, 5, 5, 4, 5, 6, 3, 7, 6)",
"+d = [0] + [-1] * n * 9",
"+for i in range(n):",
"+ for j in a:",
"+ if d[i] >= 0:",
"+ d[i + c[j]] = max(d[i + c[j]], d[i] * 10 + j)"
] | false | 0.089328 | 0.0337 | 2.650702 | [
"s509102132",
"s893478407"
] |
u010870870 | p02714 | python | s179190349 | s033419867 | 1,535 | 1,384 | 9,176 | 9,084 | Accepted | Accepted | 9.84 | N = int(eval(input()))
S = eval(input())
sum = 0
r = 0
g = 0
b = 0
for i in range(N):
if S[i] == "R":
r+=1
elif S[i] == "G":
g+=1
else:
b+=1
sum = r*g*b
for i in range(N):
for j in range((N-i)//2 +1):
try:
a = S[i]
b = S[i+j]
c = S[i+2*j]
if a!=b and b!=c and c!=a:
sum -= 1
except:
continue
print(sum) | N = int(eval(input()))
S = eval(input())
sum = 0
r = 0
g = 0
b = 0
for i in range(N):
if S[i] == "R":
r+=1
elif S[i] == "G":
g+=1
else:
b+=1
sum = r*g*b
for i in range(N):
for j in range(N):
try:
a = S[i]
b = S[i+j]
c = S[i+2*j]
if a!=b and b!=c and c!=a:
sum -= 1
except:
break
print(sum)
| 29 | 29 | 454 | 442 | N = int(eval(input()))
S = eval(input())
sum = 0
r = 0
g = 0
b = 0
for i in range(N):
if S[i] == "R":
r += 1
elif S[i] == "G":
g += 1
else:
b += 1
sum = r * g * b
for i in range(N):
for j in range((N - i) // 2 + 1):
try:
a = S[i]
b = S[i + j]
c = S[i + 2 * j]
if a != b and b != c and c != a:
sum -= 1
except:
continue
print(sum)
| N = int(eval(input()))
S = eval(input())
sum = 0
r = 0
g = 0
b = 0
for i in range(N):
if S[i] == "R":
r += 1
elif S[i] == "G":
g += 1
else:
b += 1
sum = r * g * b
for i in range(N):
for j in range(N):
try:
a = S[i]
b = S[i + j]
c = S[i + 2 * j]
if a != b and b != c and c != a:
sum -= 1
except:
break
print(sum)
| false | 0 | [
"- for j in range((N - i) // 2 + 1):",
"+ for j in range(N):",
"- continue",
"+ break"
] | false | 0.089238 | 0.046665 | 1.912288 | [
"s179190349",
"s033419867"
] |
u678167152 | p02603 | python | s531039473 | s489479300 | 63 | 29 | 62,120 | 9,204 | Accepted | Accepted | 53.97 | def solve():
ans = 0
N = int(eval(input()))
A = [float('inf')]+list(map(int, input().split()))+[-float('inf')]
UD = [0]*(N+1)
for i in range(N+1):
if A[i]>A[i+1]:
UD[i] = -1
elif A[i]<A[i+1]:
UD[i] = 1
else:
UD[i] = UD[i-1]
UD2 = [0]*N
for i in range(N):
if UD[i]>UD[i+1]:
UD2[i] = -1
elif UD[i]<UD[i+1]:
UD2[i] = 1
stock = 0
money = 1000
if -1 not in UD2:
ind = -1
else:
ind = (N-1)-UD2[::-1].index(-1)
for i in range(N):
if UD2[i]==-1:
money += A[i+1]*stock
stock = 0
if i==ind:
break
elif UD2[i]==1:
stock,money = divmod(money,A[i+1])
return money
print((solve())) | N = int(eval(input()))
A = list(map(int, input().split()))
def sell(money,stock,price):
money += price*stock
stock = 0
return money, stock
def buy(money,price):
stock,money = divmod(money,price)
return money,stock
money = 1000
stock = 0
for i in range(N):
money, stock = sell(money,stock,A[i])
if i<N-1 and A[i]<A[i+1]:
money, stock = buy(money,A[i])
print(money) | 34 | 19 | 716 | 396 | def solve():
ans = 0
N = int(eval(input()))
A = [float("inf")] + list(map(int, input().split())) + [-float("inf")]
UD = [0] * (N + 1)
for i in range(N + 1):
if A[i] > A[i + 1]:
UD[i] = -1
elif A[i] < A[i + 1]:
UD[i] = 1
else:
UD[i] = UD[i - 1]
UD2 = [0] * N
for i in range(N):
if UD[i] > UD[i + 1]:
UD2[i] = -1
elif UD[i] < UD[i + 1]:
UD2[i] = 1
stock = 0
money = 1000
if -1 not in UD2:
ind = -1
else:
ind = (N - 1) - UD2[::-1].index(-1)
for i in range(N):
if UD2[i] == -1:
money += A[i + 1] * stock
stock = 0
if i == ind:
break
elif UD2[i] == 1:
stock, money = divmod(money, A[i + 1])
return money
print((solve()))
| N = int(eval(input()))
A = list(map(int, input().split()))
def sell(money, stock, price):
money += price * stock
stock = 0
return money, stock
def buy(money, price):
stock, money = divmod(money, price)
return money, stock
money = 1000
stock = 0
for i in range(N):
money, stock = sell(money, stock, A[i])
if i < N - 1 and A[i] < A[i + 1]:
money, stock = buy(money, A[i])
print(money)
| false | 44.117647 | [
"-def solve():",
"- ans = 0",
"- N = int(eval(input()))",
"- A = [float(\"inf\")] + list(map(int, input().split())) + [-float(\"inf\")]",
"- UD = [0] * (N + 1)",
"- for i in range(N + 1):",
"- if A[i] > A[i + 1]:",
"- UD[i] = -1",
"- elif A[i] < A[i + 1]:",
"- UD[i] = 1",
"- else:",
"- UD[i] = UD[i - 1]",
"- UD2 = [0] * N",
"- for i in range(N):",
"- if UD[i] > UD[i + 1]:",
"- UD2[i] = -1",
"- elif UD[i] < UD[i + 1]:",
"- UD2[i] = 1",
"- stock = 0",
"- money = 1000",
"- if -1 not in UD2:",
"- ind = -1",
"- else:",
"- ind = (N - 1) - UD2[::-1].index(-1)",
"- for i in range(N):",
"- if UD2[i] == -1:",
"- money += A[i + 1] * stock",
"- stock = 0",
"- if i == ind:",
"- break",
"- elif UD2[i] == 1:",
"- stock, money = divmod(money, A[i + 1])",
"- return money",
"+N = int(eval(input()))",
"+A = list(map(int, input().split()))",
"-print((solve()))",
"+def sell(money, stock, price):",
"+ money += price * stock",
"+ stock = 0",
"+ return money, stock",
"+",
"+",
"+def buy(money, price):",
"+ stock, money = divmod(money, price)",
"+ return money, stock",
"+",
"+",
"+money = 1000",
"+stock = 0",
"+for i in range(N):",
"+ money, stock = sell(money, stock, A[i])",
"+ if i < N - 1 and A[i] < A[i + 1]:",
"+ money, stock = buy(money, A[i])",
"+print(money)"
] | false | 0.055658 | 0.045313 | 1.228313 | [
"s531039473",
"s489479300"
] |
u818349438 | p02852 | python | s792782025 | s895604838 | 236 | 201 | 50,672 | 10,232 | Accepted | Accepted | 14.83 | n,m = list(map(int,input().split()))
s = eval(input())
cnt = [0]*(n+1)
r = n
for i in range(n-1,-1,-1):
if s[i] == '1':
cnt[i] = -1
continue
while r > i+m:r -=1
while cnt[r] == -1:r -= 1
if i == r:
print((-1))
exit(0)
cnt[i] =cnt[r]+1
now = 0
ans = []
for i in range(n+1):
if cnt[i] == -1:continue
if cnt[i] == cnt[now]-1:
ans.append(i-now)
now = i
print((*ans))
| n,m = list(map(int,input().split()))
s = eval(input())
dp = [0]*(n+1)
r = n
for i in range(n-1,-1,-1):
if int(s[i]) == 1:
dp[i] = -1
continue
while r > i+m:r-=1
while dp[r] == -1:r -= 1
if r == i:
print((-1))
exit(0)
dp[i] = dp[r]+1
now = 0
ans = []
for i in range(n+1):
if dp[i] == -1:continue
if dp[i] != dp[now]:
ans.append(i-now)
now = i
print((*ans))
| 28 | 26 | 495 | 460 | n, m = list(map(int, input().split()))
s = eval(input())
cnt = [0] * (n + 1)
r = n
for i in range(n - 1, -1, -1):
if s[i] == "1":
cnt[i] = -1
continue
while r > i + m:
r -= 1
while cnt[r] == -1:
r -= 1
if i == r:
print((-1))
exit(0)
cnt[i] = cnt[r] + 1
now = 0
ans = []
for i in range(n + 1):
if cnt[i] == -1:
continue
if cnt[i] == cnt[now] - 1:
ans.append(i - now)
now = i
print((*ans))
| n, m = list(map(int, input().split()))
s = eval(input())
dp = [0] * (n + 1)
r = n
for i in range(n - 1, -1, -1):
if int(s[i]) == 1:
dp[i] = -1
continue
while r > i + m:
r -= 1
while dp[r] == -1:
r -= 1
if r == i:
print((-1))
exit(0)
dp[i] = dp[r] + 1
now = 0
ans = []
for i in range(n + 1):
if dp[i] == -1:
continue
if dp[i] != dp[now]:
ans.append(i - now)
now = i
print((*ans))
| false | 7.142857 | [
"-cnt = [0] * (n + 1)",
"+dp = [0] * (n + 1)",
"- if s[i] == \"1\":",
"- cnt[i] = -1",
"+ if int(s[i]) == 1:",
"+ dp[i] = -1",
"- while cnt[r] == -1:",
"+ while dp[r] == -1:",
"- if i == r:",
"+ if r == i:",
"- cnt[i] = cnt[r] + 1",
"+ dp[i] = dp[r] + 1",
"- if cnt[i] == -1:",
"+ if dp[i] == -1:",
"- if cnt[i] == cnt[now] - 1:",
"+ if dp[i] != dp[now]:"
] | false | 0.044548 | 0.044697 | 0.996649 | [
"s792782025",
"s895604838"
] |
u761320129 | p02615 | python | s018474682 | s397043162 | 162 | 134 | 31,340 | 31,584 | Accepted | Accepted | 17.28 | N = int(eval(input()))
A = list(map(int,input().split()))
A.sort()
if N==2:
print((max(A)))
exit()
ans = A.pop()
n = N-2
while A:
a = A.pop()
for _ in range(2):
n -= 1
ans += a
if n==0:
print(ans)
exit() | N = int(eval(input()))
A = list(map(int,input().split()))
A.sort(reverse=True)
ans = 0
for i in range(1,N):
ans += A[i//2]
print(ans) | 17 | 8 | 276 | 139 | N = int(eval(input()))
A = list(map(int, input().split()))
A.sort()
if N == 2:
print((max(A)))
exit()
ans = A.pop()
n = N - 2
while A:
a = A.pop()
for _ in range(2):
n -= 1
ans += a
if n == 0:
print(ans)
exit()
| N = int(eval(input()))
A = list(map(int, input().split()))
A.sort(reverse=True)
ans = 0
for i in range(1, N):
ans += A[i // 2]
print(ans)
| false | 52.941176 | [
"-A.sort()",
"-if N == 2:",
"- print((max(A)))",
"- exit()",
"-ans = A.pop()",
"-n = N - 2",
"-while A:",
"- a = A.pop()",
"- for _ in range(2):",
"- n -= 1",
"- ans += a",
"- if n == 0:",
"- print(ans)",
"- exit()",
"+A.sort(reverse=True)",
"+ans = 0",
"+for i in range(1, N):",
"+ ans += A[i // 2]",
"+print(ans)"
] | false | 0.039848 | 0.043847 | 0.908793 | [
"s018474682",
"s397043162"
] |
u325492232 | p02583 | python | s425585066 | s285515724 | 1,009 | 89 | 115,828 | 9,168 | Accepted | Accepted | 91.18 | from numba import jit
@jit
def abc175_b():
n = int(eval(input()))
l = list(map(int, input().split(' ')))
cnt = 0
for i in range(0, n - 2):
for j in range(i + 1, n):
for k in range(j + 1, n):
# 辺の長さが同じ場合は却下
if l[i] == l[j] or l[j] == l[k] or l[k] == l[i]:
continue
# 三角形になるにはa+b>c,b+c>a,c+a>b
if (l[i] + l[j] > l[k]) and (l[j] + l[k] > l[i]) and (l[k] + l[i] > l[j]):
cnt += 1
print(cnt)
if __name__ == '__main__':
abc175_b() | def abc175_b():
n = int(eval(input()))
l = list(map(int, input().split(' ')))
cnt = 0
for i in range(0, n - 2):
for j in range(i + 1, n - 1):
for k in range(j + 1, n):
# 辺の長さが同じ場合は却下
if l[i] == l[j] or l[j] == l[k] or l[k] == l[i]:
continue
# 三角形になるにはa+b>c,b+c>a,c+a>b
if (l[i] + l[j] > l[k]) and (l[j] + l[k] > l[i]) and (l[k] + l[i] > l[j]):
cnt += 1
print(cnt)
if __name__ == '__main__':
abc175_b() | 22 | 19 | 591 | 564 | from numba import jit
@jit
def abc175_b():
n = int(eval(input()))
l = list(map(int, input().split(" ")))
cnt = 0
for i in range(0, n - 2):
for j in range(i + 1, n):
for k in range(j + 1, n):
# 辺の長さが同じ場合は却下
if l[i] == l[j] or l[j] == l[k] or l[k] == l[i]:
continue
# 三角形になるにはa+b>c,b+c>a,c+a>b
if (
(l[i] + l[j] > l[k])
and (l[j] + l[k] > l[i])
and (l[k] + l[i] > l[j])
):
cnt += 1
print(cnt)
if __name__ == "__main__":
abc175_b()
| def abc175_b():
n = int(eval(input()))
l = list(map(int, input().split(" ")))
cnt = 0
for i in range(0, n - 2):
for j in range(i + 1, n - 1):
for k in range(j + 1, n):
# 辺の長さが同じ場合は却下
if l[i] == l[j] or l[j] == l[k] or l[k] == l[i]:
continue
# 三角形になるにはa+b>c,b+c>a,c+a>b
if (
(l[i] + l[j] > l[k])
and (l[j] + l[k] > l[i])
and (l[k] + l[i] > l[j])
):
cnt += 1
print(cnt)
if __name__ == "__main__":
abc175_b()
| false | 13.636364 | [
"-from numba import jit",
"-",
"-",
"-@jit",
"- for j in range(i + 1, n):",
"+ for j in range(i + 1, n - 1):"
] | false | 0.111454 | 0.074998 | 1.486086 | [
"s425585066",
"s285515724"
] |
u406158207 | p03109 | python | s959142653 | s262000769 | 19 | 17 | 2,940 | 2,940 | Accepted | Accepted | 10.53 | Y,M,D=list(map(int,input().split("/")))
if M<=4:
print("Heisei")
else:
print("TBD")
| X=eval(input())
A,B,C=(X.split('/'))
B=int(B)
C=int(C)
if B<=4:
print("Heisei")
else:
print("TBD") | 5 | 9 | 86 | 109 | Y, M, D = list(map(int, input().split("/")))
if M <= 4:
print("Heisei")
else:
print("TBD")
| X = eval(input())
A, B, C = X.split("/")
B = int(B)
C = int(C)
if B <= 4:
print("Heisei")
else:
print("TBD")
| false | 44.444444 | [
"-Y, M, D = list(map(int, input().split(\"/\")))",
"-if M <= 4:",
"+X = eval(input())",
"+A, B, C = X.split(\"/\")",
"+B = int(B)",
"+C = int(C)",
"+if B <= 4:"
] | false | 0.118185 | 0.04459 | 2.650484 | [
"s959142653",
"s262000769"
] |
u254871849 | p03212 | python | s657273047 | s999612077 | 61 | 43 | 4,212 | 4,212 | Accepted | Accepted | 29.51 | import sys
from itertools import product
from bisect import bisect_right as bi_r
shichigosan = set('357')
cand = []
for i in range(3, 10):
for x in product('357', repeat=i):
x = ''.join(x)
if set(x) == shichigosan:
cand.append(int(''.join(x)))
n = int(sys.stdin.readline().rstrip())
def main():
return bi_r(cand, n)
if __name__ == '__main__':
ans = main()
print(ans) | import sys
from itertools import product
from bisect import bisect_right as bi_r
cand = [int(''.join(p)) for i in range(3, 10) for p in product('357', repeat=i) if len(set(p)) == 3]
n = int(sys.stdin.readline().rstrip())
def main():
print((bi_r(cand, n)))
if __name__ == '__main__':
main() | 21 | 13 | 435 | 312 | import sys
from itertools import product
from bisect import bisect_right as bi_r
shichigosan = set("357")
cand = []
for i in range(3, 10):
for x in product("357", repeat=i):
x = "".join(x)
if set(x) == shichigosan:
cand.append(int("".join(x)))
n = int(sys.stdin.readline().rstrip())
def main():
return bi_r(cand, n)
if __name__ == "__main__":
ans = main()
print(ans)
| import sys
from itertools import product
from bisect import bisect_right as bi_r
cand = [
int("".join(p))
for i in range(3, 10)
for p in product("357", repeat=i)
if len(set(p)) == 3
]
n = int(sys.stdin.readline().rstrip())
def main():
print((bi_r(cand, n)))
if __name__ == "__main__":
main()
| false | 38.095238 | [
"-shichigosan = set(\"357\")",
"-cand = []",
"-for i in range(3, 10):",
"- for x in product(\"357\", repeat=i):",
"- x = \"\".join(x)",
"- if set(x) == shichigosan:",
"- cand.append(int(\"\".join(x)))",
"+cand = [",
"+ int(\"\".join(p))",
"+ for i in range(3, 10)",
"+ for p in product(\"357\", repeat=i)",
"+ if len(set(p)) == 3",
"+]",
"- return bi_r(cand, n)",
"+ print((bi_r(cand, n)))",
"- ans = main()",
"- print(ans)",
"+ main()"
] | false | 0.07758 | 0.059772 | 1.297918 | [
"s657273047",
"s999612077"
] |
u333945892 | p03261 | python | s236757463 | s625866841 | 38 | 31 | 4,456 | 4,332 | Accepted | Accepted | 18.42 | from collections import defaultdict,deque
import sys,heapq,bisect,math,itertools,string,queue,datetime
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
N = int(eval(input()))
ww = [eval(input()) for i in range(N)]
if len(set(ww)) != N:
print('No')
else:
for i in range(N-1):
a = ww[i]
b = ww[i+1]
if a[-1] != b[0]:
print('No')
sys.exit()
print('Yes')
| from collections import defaultdict
import sys,heapq,bisect,math,itertools,string,queue,datetime
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inpl(): return list(map(int, input().split()))
def inpl_str(): return list(input().split())
N = int(eval(input()))
li = []
start = True
for i in range(N):
w = eval(input())
if w in li:
print('No')
exit()
li.append(w)
if start:
start = False
else:
if bef[-1] != w[0]:
print('No')
exit()
bef = w
print('Yes')
| 22 | 28 | 496 | 585 | from collections import defaultdict, deque
import sys, heapq, bisect, math, itertools, string, queue, datetime
sys.setrecursionlimit(10**8)
INF = float("inf")
mod = 10**9 + 7
eps = 10**-7
def inpl():
return list(map(int, input().split()))
def inpls():
return list(input().split())
N = int(eval(input()))
ww = [eval(input()) for i in range(N)]
if len(set(ww)) != N:
print("No")
else:
for i in range(N - 1):
a = ww[i]
b = ww[i + 1]
if a[-1] != b[0]:
print("No")
sys.exit()
print("Yes")
| from collections import defaultdict
import sys, heapq, bisect, math, itertools, string, queue, datetime
sys.setrecursionlimit(10**8)
INF = float("inf")
mod = 10**9 + 7
eps = 10**-7
def inpl():
return list(map(int, input().split()))
def inpl_str():
return list(input().split())
N = int(eval(input()))
li = []
start = True
for i in range(N):
w = eval(input())
if w in li:
print("No")
exit()
li.append(w)
if start:
start = False
else:
if bef[-1] != w[0]:
print("No")
exit()
bef = w
print("Yes")
| false | 21.428571 | [
"-from collections import defaultdict, deque",
"+from collections import defaultdict",
"-def inpls():",
"+def inpl_str():",
"-ww = [eval(input()) for i in range(N)]",
"-if len(set(ww)) != N:",
"- print(\"No\")",
"-else:",
"- for i in range(N - 1):",
"- a = ww[i]",
"- b = ww[i + 1]",
"- if a[-1] != b[0]:",
"+li = []",
"+start = True",
"+for i in range(N):",
"+ w = eval(input())",
"+ if w in li:",
"+ print(\"No\")",
"+ exit()",
"+ li.append(w)",
"+ if start:",
"+ start = False",
"+ else:",
"+ if bef[-1] != w[0]:",
"- sys.exit()",
"- print(\"Yes\")",
"+ exit()",
"+ bef = w",
"+print(\"Yes\")"
] | false | 0.03543 | 0.037071 | 0.955723 | [
"s236757463",
"s625866841"
] |
u945359338 | p02595 | python | s492315713 | s600709561 | 1,512 | 840 | 57,420 | 57,424 | Accepted | Accepted | 44.44 | from decimal import *
getcontext().prec = 50
N, D = list(map(int, input().split()))
def distance(x1, x2, y1, y2):
dx = x2-x1
dy = y2-y1
return (dx*dx + dy*dy).sqrt()
X = [0] * N
Y = [0] * N
for i in range(N):
X[i], Y[i] = list(map(Decimal, input().split()))
ans = 0
for i in range(N):
if (distance(0, X[i], 0, Y[i]) <= D):
ans += 1
print(ans)
| from decimal import *
getcontext().prec = 14
N, D = list(map(int, input().split()))
def distance(x1, x2, y1, y2):
dx = x2-x1
dy = y2-y1
return (dx*dx + dy*dy).sqrt()
X = [0] * N
Y = [0] * N
ans = 0
for i in range(N):
X[i], Y[i] = list(map(Decimal, input().split()))
if (distance(0, X[i], 0, Y[i]) <= D):
ans += 1
print(ans)
| 22 | 21 | 386 | 366 | from decimal import *
getcontext().prec = 50
N, D = list(map(int, input().split()))
def distance(x1, x2, y1, y2):
dx = x2 - x1
dy = y2 - y1
return (dx * dx + dy * dy).sqrt()
X = [0] * N
Y = [0] * N
for i in range(N):
X[i], Y[i] = list(map(Decimal, input().split()))
ans = 0
for i in range(N):
if distance(0, X[i], 0, Y[i]) <= D:
ans += 1
print(ans)
| from decimal import *
getcontext().prec = 14
N, D = list(map(int, input().split()))
def distance(x1, x2, y1, y2):
dx = x2 - x1
dy = y2 - y1
return (dx * dx + dy * dy).sqrt()
X = [0] * N
Y = [0] * N
ans = 0
for i in range(N):
X[i], Y[i] = list(map(Decimal, input().split()))
if distance(0, X[i], 0, Y[i]) <= D:
ans += 1
print(ans)
| false | 4.545455 | [
"-getcontext().prec = 50",
"+getcontext().prec = 14",
"+ans = 0",
"-ans = 0",
"-for i in range(N):"
] | false | 0.038882 | 0.105668 | 0.367961 | [
"s492315713",
"s600709561"
] |
u600402037 | p03464 | python | s829499626 | s895064691 | 119 | 108 | 14,252 | 14,224 | Accepted | Accepted | 9.24 | K = int(eval(input()))
A = list(map(int, input().split()))
min = 2
max = 2
for i in range(K-1, -1, -1):
if max < A[i]:
print((-1))
exit()
min += (-min) % A[i]
max -= max % A[i]
max += A[i] - 1
if max < min:
print((-1))
exit()
print((min, max))
| K = int(eval(input()))
A = list(map(int, input().split()))
min = 2
max = 2
for i in range(K-1, -1, -1):
min += (-min) % A[i]
max -= max % A[i]
max += A[i] - 1
if max < min:
print((-1))
exit()
print((min, max))
| 15 | 12 | 298 | 227 | K = int(eval(input()))
A = list(map(int, input().split()))
min = 2
max = 2
for i in range(K - 1, -1, -1):
if max < A[i]:
print((-1))
exit()
min += (-min) % A[i]
max -= max % A[i]
max += A[i] - 1
if max < min:
print((-1))
exit()
print((min, max))
| K = int(eval(input()))
A = list(map(int, input().split()))
min = 2
max = 2
for i in range(K - 1, -1, -1):
min += (-min) % A[i]
max -= max % A[i]
max += A[i] - 1
if max < min:
print((-1))
exit()
print((min, max))
| false | 20 | [
"- if max < A[i]:",
"- print((-1))",
"- exit()",
"- if max < min:",
"- print((-1))",
"- exit()",
"+if max < min:",
"+ print((-1))",
"+ exit()"
] | false | 0.106579 | 0.086469 | 1.23257 | [
"s829499626",
"s895064691"
] |
u966695411 | p03817 | python | s676996836 | s551474392 | 24 | 21 | 3,188 | 3,064 | Accepted | Accepted | 12.5 | N = int(eval(input()))
if N < 11:
d, m = divmod(N, 6)
print((d + (m>0)))
else:
d, m = divmod(N, 11)
a = (1 if m else 0) if m < 7 else 2
print((d * 2 + a)) | N = int(eval(input()))
d, m = divmod(N, 11)
a = (1 if m else 0) if m < 7 else 2
print((d * 2 + a)) | 9 | 4 | 173 | 93 | N = int(eval(input()))
if N < 11:
d, m = divmod(N, 6)
print((d + (m > 0)))
else:
d, m = divmod(N, 11)
a = (1 if m else 0) if m < 7 else 2
print((d * 2 + a))
| N = int(eval(input()))
d, m = divmod(N, 11)
a = (1 if m else 0) if m < 7 else 2
print((d * 2 + a))
| false | 55.555556 | [
"-if N < 11:",
"- d, m = divmod(N, 6)",
"- print((d + (m > 0)))",
"-else:",
"- d, m = divmod(N, 11)",
"- a = (1 if m else 0) if m < 7 else 2",
"- print((d * 2 + a))",
"+d, m = divmod(N, 11)",
"+a = (1 if m else 0) if m < 7 else 2",
"+print((d * 2 + a))"
] | false | 0.041738 | 0.040286 | 1.036034 | [
"s676996836",
"s551474392"
] |
u580697892 | p02681 | python | s551603047 | s463807794 | 21 | 19 | 9,096 | 9,052 | Accepted | Accepted | 9.52 | #coding: utf-8
S = eval(input())
T = eval(input())
if S == T[:-1]:
print("Yes")
else:
print("No") | s = eval(input())
t = eval(input())
print(("Yes" if s == t[:-1] else "No")) | 7 | 3 | 99 | 63 | # coding: utf-8
S = eval(input())
T = eval(input())
if S == T[:-1]:
print("Yes")
else:
print("No")
| s = eval(input())
t = eval(input())
print(("Yes" if s == t[:-1] else "No"))
| false | 57.142857 | [
"-# coding: utf-8",
"-S = eval(input())",
"-T = eval(input())",
"-if S == T[:-1]:",
"- print(\"Yes\")",
"-else:",
"- print(\"No\")",
"+s = eval(input())",
"+t = eval(input())",
"+print((\"Yes\" if s == t[:-1] else \"No\"))"
] | false | 0.036739 | 0.035956 | 1.021776 | [
"s551603047",
"s463807794"
] |
u392319141 | p02900 | python | s540307001 | s209756887 | 367 | 239 | 135,800 | 99,040 | Accepted | Accepted | 34.88 | import sys
from heapq import heappop, heappush
from operator import itemgetter
from collections import deque, defaultdict, Counter
from bisect import bisect_left, bisect_right
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
MOD = 10**9 + 7
INF = float('inf')
def primeCount(N):
R = int(N**(0.5)) + 1 # 素数の範囲
primes = {} # 素数のリスト
n = N
for num in range(2, R):
primes[num] = 0
while n % num == 0:
n //= num
primes[num] += 1
if n > 1 :
primes[n] = 1
return { key : val for key, val in list(primes.items()) if val > 0} # フィルターをかける
def sol():
A, B = list(map(int, input().split()))
primeA = primeCount(A)
primeB = primeCount(B)
ans = 1
for a in list(primeA.keys()):
if a in primeB:
ans += 1
print(ans)
sol() | A, B = list(map(int, input().split()))
def primeCount(N):
R = int(N**(0.5)) + 1 # 素数の範囲
primes = {} # 素数のリスト
n = N
for num in range(2, R):
primes[num] = 0
while n % num == 0:
n //= num
primes[num] += 1
if n > 1 :
primes[n] = 1
return { key : val for key, val in list(primes.items()) if val > 0} # フィルターをかける
primeA = primeCount(A)
ans = 1
prd = 1
for p in sorted(primeA.keys()):
if B % p == 0 and prd % p != 0:
prd *= p
ans += 1
print(ans)
| 37 | 23 | 855 | 546 | import sys
from heapq import heappop, heappush
from operator import itemgetter
from collections import deque, defaultdict, Counter
from bisect import bisect_left, bisect_right
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
MOD = 10**9 + 7
INF = float("inf")
def primeCount(N):
R = int(N ** (0.5)) + 1 # 素数の範囲
primes = {} # 素数のリスト
n = N
for num in range(2, R):
primes[num] = 0
while n % num == 0:
n //= num
primes[num] += 1
if n > 1:
primes[n] = 1
return {key: val for key, val in list(primes.items()) if val > 0} # フィルターをかける
def sol():
A, B = list(map(int, input().split()))
primeA = primeCount(A)
primeB = primeCount(B)
ans = 1
for a in list(primeA.keys()):
if a in primeB:
ans += 1
print(ans)
sol()
| A, B = list(map(int, input().split()))
def primeCount(N):
R = int(N ** (0.5)) + 1 # 素数の範囲
primes = {} # 素数のリスト
n = N
for num in range(2, R):
primes[num] = 0
while n % num == 0:
n //= num
primes[num] += 1
if n > 1:
primes[n] = 1
return {key: val for key, val in list(primes.items()) if val > 0} # フィルターをかける
primeA = primeCount(A)
ans = 1
prd = 1
for p in sorted(primeA.keys()):
if B % p == 0 and prd % p != 0:
prd *= p
ans += 1
print(ans)
| false | 37.837838 | [
"-import sys",
"-from heapq import heappop, heappush",
"-from operator import itemgetter",
"-from collections import deque, defaultdict, Counter",
"-from bisect import bisect_left, bisect_right",
"-",
"-input = sys.stdin.readline",
"-sys.setrecursionlimit(10**7)",
"-MOD = 10**9 + 7",
"-INF = float(\"inf\")",
"+A, B = list(map(int, input().split()))",
"-def sol():",
"- A, B = list(map(int, input().split()))",
"- primeA = primeCount(A)",
"- primeB = primeCount(B)",
"- ans = 1",
"- for a in list(primeA.keys()):",
"- if a in primeB:",
"- ans += 1",
"- print(ans)",
"-",
"-",
"-sol()",
"+primeA = primeCount(A)",
"+ans = 1",
"+prd = 1",
"+for p in sorted(primeA.keys()):",
"+ if B % p == 0 and prd % p != 0:",
"+ prd *= p",
"+ ans += 1",
"+print(ans)"
] | false | 0.035288 | 0.035535 | 0.993049 | [
"s540307001",
"s209756887"
] |
u620868411 | p03634 | python | s151220546 | s230006320 | 1,418 | 1,004 | 47,040 | 48,196 | Accepted | Accepted | 29.2 | # coding=utf-8
N = int(eval(input()))
tree = [[]for x in range(N)]
depth = [0 for x in range(N)]
for _ in range(N-1):
line = input().split(" ")
a = int(line[0])-1
b = int(line[1])-1
c = int(line[2])
tree[a].append((b, c))
tree[b].append((a, c))
line = input().split(" ")
Q = int(line[0])
K = int(line[1])-1
# def dfs(v, p, d):
# depth[v] = d
# for e in tree[v]:
# if e[0]==p:
# continue
# dfs(e[0], v, d+e[1])
# dfs(K, -1, 0)
s = [(K, -1, 0)]
while len(s)>0:
(v, p, d) = s.pop()
depth[v] = d
for e in tree[v]:
if e[0]==p:
continue
s.append((e[0], v, d+e[1]))
for _ in range(Q):
line = input(" ").split(" ")
x = int(line[0])-1
y = int(line[1])-1
print((str(depth[x]+depth[y])))
| # -*- coding: utf-8 -*-
inf = 10**16
n = int(eval(input()))
edge = [[] for _ in range(n)]
for _ in range(n-1):
a,b,c = list(map(int, input().split()))
a -= 1
b -= 1
edge[a].append((b,c))
edge[b].append((a,c))
q,k = list(map(int, input().split()))
k -= 1
d = [inf for _ in range(n)]
d[k] = 0
stack = [k]
while len(stack)>0:
v = stack.pop()
for u,c in edge[v]:
if d[u]==inf:
d[u] = d[v]+c
stack.append(u)
res = []
for _ in range(q):
x,y = list(map(int, input().split()))
x -= 1
y -= 1
res.append(d[x]+d[y])
for c in res:
print(c)
| 40 | 33 | 830 | 620 | # coding=utf-8
N = int(eval(input()))
tree = [[] for x in range(N)]
depth = [0 for x in range(N)]
for _ in range(N - 1):
line = input().split(" ")
a = int(line[0]) - 1
b = int(line[1]) - 1
c = int(line[2])
tree[a].append((b, c))
tree[b].append((a, c))
line = input().split(" ")
Q = int(line[0])
K = int(line[1]) - 1
# def dfs(v, p, d):
# depth[v] = d
# for e in tree[v]:
# if e[0]==p:
# continue
# dfs(e[0], v, d+e[1])
# dfs(K, -1, 0)
s = [(K, -1, 0)]
while len(s) > 0:
(v, p, d) = s.pop()
depth[v] = d
for e in tree[v]:
if e[0] == p:
continue
s.append((e[0], v, d + e[1]))
for _ in range(Q):
line = input(" ").split(" ")
x = int(line[0]) - 1
y = int(line[1]) - 1
print((str(depth[x] + depth[y])))
| # -*- coding: utf-8 -*-
inf = 10**16
n = int(eval(input()))
edge = [[] for _ in range(n)]
for _ in range(n - 1):
a, b, c = list(map(int, input().split()))
a -= 1
b -= 1
edge[a].append((b, c))
edge[b].append((a, c))
q, k = list(map(int, input().split()))
k -= 1
d = [inf for _ in range(n)]
d[k] = 0
stack = [k]
while len(stack) > 0:
v = stack.pop()
for u, c in edge[v]:
if d[u] == inf:
d[u] = d[v] + c
stack.append(u)
res = []
for _ in range(q):
x, y = list(map(int, input().split()))
x -= 1
y -= 1
res.append(d[x] + d[y])
for c in res:
print(c)
| false | 17.5 | [
"-# coding=utf-8",
"-N = int(eval(input()))",
"-tree = [[] for x in range(N)]",
"-depth = [0 for x in range(N)]",
"-for _ in range(N - 1):",
"- line = input().split(\" \")",
"- a = int(line[0]) - 1",
"- b = int(line[1]) - 1",
"- c = int(line[2])",
"- tree[a].append((b, c))",
"- tree[b].append((a, c))",
"-line = input().split(\" \")",
"-Q = int(line[0])",
"-K = int(line[1]) - 1",
"-# def dfs(v, p, d):",
"-# depth[v] = d",
"-# for e in tree[v]:",
"-# if e[0]==p:",
"-# continue",
"-# dfs(e[0], v, d+e[1])",
"-# dfs(K, -1, 0)",
"-s = [(K, -1, 0)]",
"-while len(s) > 0:",
"- (v, p, d) = s.pop()",
"- depth[v] = d",
"- for e in tree[v]:",
"- if e[0] == p:",
"- continue",
"- s.append((e[0], v, d + e[1]))",
"-for _ in range(Q):",
"- line = input(\" \").split(\" \")",
"- x = int(line[0]) - 1",
"- y = int(line[1]) - 1",
"- print((str(depth[x] + depth[y])))",
"+# -*- coding: utf-8 -*-",
"+inf = 10**16",
"+n = int(eval(input()))",
"+edge = [[] for _ in range(n)]",
"+for _ in range(n - 1):",
"+ a, b, c = list(map(int, input().split()))",
"+ a -= 1",
"+ b -= 1",
"+ edge[a].append((b, c))",
"+ edge[b].append((a, c))",
"+q, k = list(map(int, input().split()))",
"+k -= 1",
"+d = [inf for _ in range(n)]",
"+d[k] = 0",
"+stack = [k]",
"+while len(stack) > 0:",
"+ v = stack.pop()",
"+ for u, c in edge[v]:",
"+ if d[u] == inf:",
"+ d[u] = d[v] + c",
"+ stack.append(u)",
"+res = []",
"+for _ in range(q):",
"+ x, y = list(map(int, input().split()))",
"+ x -= 1",
"+ y -= 1",
"+ res.append(d[x] + d[y])",
"+for c in res:",
"+ print(c)"
] | false | 0.045336 | 0.083964 | 0.539942 | [
"s151220546",
"s230006320"
] |
u677523557 | p02992 | python | s621450244 | s177384141 | 491 | 236 | 91,372 | 148,100 | Accepted | Accepted | 51.93 | N, K = list(map(int, input().split()))
mod = 10**9+7
n = 1
A = []
while True:
A.append(N//n)
if N//(n+1) < n+1: break
n += 1
A.append(n)
L = 2*n
dp = [[0]*L for _ in range(K)]
for l in range(n):
dp[0][l] = 1
i = 0
for l in reversed(list(range(n, L))):
dp[0][l] = A[i] - A[i+1]
i += 1
for k in range(1, K):
s = 0
for l in reversed(list(range(L))):
s = (s+dp[k-1][L-l-1]) % mod
dp[k][l] = s * dp[0][l] % mod
ans = 0
for l in range(L):
ans = (ans + dp[K-1][l]) % mod
print(ans) | import sys
input = sys.stdin.readline
import math
mod = 10**9+7
N, K = list(map(int, input().split()))
K -= 1
P = set()
inv = {}
for i in range(1, int(math.sqrt(N)+2)):
if i**2 > N: break
P.add(i)
P.add(N//i)
if i not in inv:
inv[i] = N//i
if N//i not in inv:
inv[N//i] = i
P1 = sorted(list(P))
T = len(P1)
M = [1]
for i in range(T-1):
M.append(P1[i+1]-P1[i])
co_to_ind = {}
for i, p in enumerate(P1):
co_to_ind[p] = i
Inv = []
for p in P1:
Inv.append(co_to_ind[inv[p]])
dp = [[0]*T for _ in range(K+1)]
dp[0] = M
for i in range(K):
tosum = [0]*T
for ik in range(T):
j = Inv[ik]
tosum[j] = (tosum[j] + dp[i][ik]) % mod
sumup = 0
for ik in reversed(list(range(T))):
sumup = (sumup + tosum[ik]) % mod
dp[i+1][ik] = sumup * M[ik] % mod
ans = 0
for t in range(T):
ans = (ans + dp[K][t]) % mod
print(ans) | 32 | 56 | 545 | 956 | N, K = list(map(int, input().split()))
mod = 10**9 + 7
n = 1
A = []
while True:
A.append(N // n)
if N // (n + 1) < n + 1:
break
n += 1
A.append(n)
L = 2 * n
dp = [[0] * L for _ in range(K)]
for l in range(n):
dp[0][l] = 1
i = 0
for l in reversed(list(range(n, L))):
dp[0][l] = A[i] - A[i + 1]
i += 1
for k in range(1, K):
s = 0
for l in reversed(list(range(L))):
s = (s + dp[k - 1][L - l - 1]) % mod
dp[k][l] = s * dp[0][l] % mod
ans = 0
for l in range(L):
ans = (ans + dp[K - 1][l]) % mod
print(ans)
| import sys
input = sys.stdin.readline
import math
mod = 10**9 + 7
N, K = list(map(int, input().split()))
K -= 1
P = set()
inv = {}
for i in range(1, int(math.sqrt(N) + 2)):
if i**2 > N:
break
P.add(i)
P.add(N // i)
if i not in inv:
inv[i] = N // i
if N // i not in inv:
inv[N // i] = i
P1 = sorted(list(P))
T = len(P1)
M = [1]
for i in range(T - 1):
M.append(P1[i + 1] - P1[i])
co_to_ind = {}
for i, p in enumerate(P1):
co_to_ind[p] = i
Inv = []
for p in P1:
Inv.append(co_to_ind[inv[p]])
dp = [[0] * T for _ in range(K + 1)]
dp[0] = M
for i in range(K):
tosum = [0] * T
for ik in range(T):
j = Inv[ik]
tosum[j] = (tosum[j] + dp[i][ik]) % mod
sumup = 0
for ik in reversed(list(range(T))):
sumup = (sumup + tosum[ik]) % mod
dp[i + 1][ik] = sumup * M[ik] % mod
ans = 0
for t in range(T):
ans = (ans + dp[K][t]) % mod
print(ans)
| false | 42.857143 | [
"+import sys",
"+",
"+input = sys.stdin.readline",
"+import math",
"+",
"+mod = 10**9 + 7",
"-mod = 10**9 + 7",
"-n = 1",
"-A = []",
"-while True:",
"- A.append(N // n)",
"- if N // (n + 1) < n + 1:",
"+K -= 1",
"+P = set()",
"+inv = {}",
"+for i in range(1, int(math.sqrt(N) + 2)):",
"+ if i**2 > N:",
"- n += 1",
"-A.append(n)",
"-L = 2 * n",
"-dp = [[0] * L for _ in range(K)]",
"-for l in range(n):",
"- dp[0][l] = 1",
"-i = 0",
"-for l in reversed(list(range(n, L))):",
"- dp[0][l] = A[i] - A[i + 1]",
"- i += 1",
"-for k in range(1, K):",
"- s = 0",
"- for l in reversed(list(range(L))):",
"- s = (s + dp[k - 1][L - l - 1]) % mod",
"- dp[k][l] = s * dp[0][l] % mod",
"+ P.add(i)",
"+ P.add(N // i)",
"+ if i not in inv:",
"+ inv[i] = N // i",
"+ if N // i not in inv:",
"+ inv[N // i] = i",
"+P1 = sorted(list(P))",
"+T = len(P1)",
"+M = [1]",
"+for i in range(T - 1):",
"+ M.append(P1[i + 1] - P1[i])",
"+co_to_ind = {}",
"+for i, p in enumerate(P1):",
"+ co_to_ind[p] = i",
"+Inv = []",
"+for p in P1:",
"+ Inv.append(co_to_ind[inv[p]])",
"+dp = [[0] * T for _ in range(K + 1)]",
"+dp[0] = M",
"+for i in range(K):",
"+ tosum = [0] * T",
"+ for ik in range(T):",
"+ j = Inv[ik]",
"+ tosum[j] = (tosum[j] + dp[i][ik]) % mod",
"+ sumup = 0",
"+ for ik in reversed(list(range(T))):",
"+ sumup = (sumup + tosum[ik]) % mod",
"+ dp[i + 1][ik] = sumup * M[ik] % mod",
"-for l in range(L):",
"- ans = (ans + dp[K - 1][l]) % mod",
"+for t in range(T):",
"+ ans = (ans + dp[K][t]) % mod"
] | false | 0.251241 | 0.34327 | 0.731907 | [
"s621450244",
"s177384141"
] |
u631277801 | p03503 | python | s482203051 | s658968331 | 254 | 224 | 3,064 | 3,064 | Accepted | Accepted | 11.81 | N = int(eval(input()))
F = []
P = []
for i in range(N):
F.append(list(map(int, input().split())))
for i in range(N):
P.append(list(map(int, input().split())))
TIME = 10
prof_cand = []
for bit in range(1,1<<TIME):
onBiz = []
with_n = []
for t in range(TIME):
if bit & (1<<t):
onBiz.append(1)
else:
onBiz.append(0)
for n in range(N):
with_n.append(sum([F[n][i]*onBiz[i] for i in range(TIME)]))
prof = sum([P[i][with_n[i]] for i in range(N)])
prof_cand.append(prof)
print((max(prof_cand))) | import sys
stdin = sys.stdin
sys.setrecursionlimit(10**5)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x)-1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
def dfs(depth:int, inbis:str, f:list, p:list):
if depth != 10:
return max(dfs(depth+1, inbis+"1",f,p),
dfs(depth+1, inbis+"0",f,p))
else:
if inbis.count("1") == 0:
return -10**10
else:
biz = [int(i) for i in inbis]
ans = 0
for i in range(len(f)):
common = [biz[j]*f[i][j] for j in range(10)]
ans += p[i][sum(common)]
return ans
n = ni()
f = []
p = []
for _ in range(n):
f.append(list(li()))
for _ in range(n):
p.append(list(li()))
print((dfs(0,"",f,p))) | 27 | 40 | 609 | 1,103 | N = int(eval(input()))
F = []
P = []
for i in range(N):
F.append(list(map(int, input().split())))
for i in range(N):
P.append(list(map(int, input().split())))
TIME = 10
prof_cand = []
for bit in range(1, 1 << TIME):
onBiz = []
with_n = []
for t in range(TIME):
if bit & (1 << t):
onBiz.append(1)
else:
onBiz.append(0)
for n in range(N):
with_n.append(sum([F[n][i] * onBiz[i] for i in range(TIME)]))
prof = sum([P[i][with_n[i]] for i in range(N)])
prof_cand.append(prof)
print((max(prof_cand)))
| import sys
stdin = sys.stdin
sys.setrecursionlimit(10**5)
def li():
return list(map(int, stdin.readline().split()))
def li_():
return [int(x) - 1 for x in stdin.readline().split()]
def lf():
return list(map(float, stdin.readline().split()))
def ls():
return stdin.readline().split()
def ns():
return stdin.readline().rstrip()
def lc():
return list(ns())
def ni():
return int(stdin.readline())
def nf():
return float(stdin.readline())
def dfs(depth: int, inbis: str, f: list, p: list):
if depth != 10:
return max(dfs(depth + 1, inbis + "1", f, p), dfs(depth + 1, inbis + "0", f, p))
else:
if inbis.count("1") == 0:
return -(10**10)
else:
biz = [int(i) for i in inbis]
ans = 0
for i in range(len(f)):
common = [biz[j] * f[i][j] for j in range(10)]
ans += p[i][sum(common)]
return ans
n = ni()
f = []
p = []
for _ in range(n):
f.append(list(li()))
for _ in range(n):
p.append(list(li()))
print((dfs(0, "", f, p)))
| false | 32.5 | [
"-N = int(eval(input()))",
"-F = []",
"-P = []",
"-for i in range(N):",
"- F.append(list(map(int, input().split())))",
"-for i in range(N):",
"- P.append(list(map(int, input().split())))",
"-TIME = 10",
"-prof_cand = []",
"-for bit in range(1, 1 << TIME):",
"- onBiz = []",
"- with_n = []",
"- for t in range(TIME):",
"- if bit & (1 << t):",
"- onBiz.append(1)",
"+import sys",
"+",
"+stdin = sys.stdin",
"+sys.setrecursionlimit(10**5)",
"+",
"+",
"+def li():",
"+ return list(map(int, stdin.readline().split()))",
"+",
"+",
"+def li_():",
"+ return [int(x) - 1 for x in stdin.readline().split()]",
"+",
"+",
"+def lf():",
"+ return list(map(float, stdin.readline().split()))",
"+",
"+",
"+def ls():",
"+ return stdin.readline().split()",
"+",
"+",
"+def ns():",
"+ return stdin.readline().rstrip()",
"+",
"+",
"+def lc():",
"+ return list(ns())",
"+",
"+",
"+def ni():",
"+ return int(stdin.readline())",
"+",
"+",
"+def nf():",
"+ return float(stdin.readline())",
"+",
"+",
"+def dfs(depth: int, inbis: str, f: list, p: list):",
"+ if depth != 10:",
"+ return max(dfs(depth + 1, inbis + \"1\", f, p), dfs(depth + 1, inbis + \"0\", f, p))",
"+ else:",
"+ if inbis.count(\"1\") == 0:",
"+ return -(10**10)",
"- onBiz.append(0)",
"- for n in range(N):",
"- with_n.append(sum([F[n][i] * onBiz[i] for i in range(TIME)]))",
"- prof = sum([P[i][with_n[i]] for i in range(N)])",
"- prof_cand.append(prof)",
"-print((max(prof_cand)))",
"+ biz = [int(i) for i in inbis]",
"+ ans = 0",
"+ for i in range(len(f)):",
"+ common = [biz[j] * f[i][j] for j in range(10)]",
"+ ans += p[i][sum(common)]",
"+ return ans",
"+",
"+",
"+n = ni()",
"+f = []",
"+p = []",
"+for _ in range(n):",
"+ f.append(list(li()))",
"+for _ in range(n):",
"+ p.append(list(li()))",
"+print((dfs(0, \"\", f, p)))"
] | false | 0.095621 | 0.041836 | 2.285581 | [
"s482203051",
"s658968331"
] |
u767664985 | p02996 | python | s416765949 | s816851916 | 1,241 | 1,043 | 93,912 | 55,264 | Accepted | Accepted | 15.95 | N = int(eval(input()))
X = [list(map(int, input().split())) for _ in range(N)]
X = sorted(X, key = lambda x: x[1])
# a[i]はA[i]まで終わらせるためにかかる累積時間
a = [0] * N
a[0] = X[0][0]
for i in range(1, N):
a[i] = a[i - 1] + X[i][0]
for j in range(N):
if a[j] > X[j][1]:
print("No")
exit()
print("Yes")
| # 締切の早いものから順番に見ていくのが最適戦略
N = int(eval(input()))
X = [list(map(int, input().split())) for _ in range(N)]
X = sorted(X, key=lambda x: x[1]) # B (締切の早い順にソート)
res = 0
for i in range(N):
res += X[i][0]
if res > X[i][1]:
print("No")
exit()
print("Yes")
| 15 | 12 | 305 | 278 | N = int(eval(input()))
X = [list(map(int, input().split())) for _ in range(N)]
X = sorted(X, key=lambda x: x[1])
# a[i]はA[i]まで終わらせるためにかかる累積時間
a = [0] * N
a[0] = X[0][0]
for i in range(1, N):
a[i] = a[i - 1] + X[i][0]
for j in range(N):
if a[j] > X[j][1]:
print("No")
exit()
print("Yes")
| # 締切の早いものから順番に見ていくのが最適戦略
N = int(eval(input()))
X = [list(map(int, input().split())) for _ in range(N)]
X = sorted(X, key=lambda x: x[1]) # B (締切の早い順にソート)
res = 0
for i in range(N):
res += X[i][0]
if res > X[i][1]:
print("No")
exit()
print("Yes")
| false | 20 | [
"+# 締切の早いものから順番に見ていくのが最適戦略",
"-X = sorted(X, key=lambda x: x[1])",
"-# a[i]はA[i]まで終わらせるためにかかる累積時間",
"-a = [0] * N",
"-a[0] = X[0][0]",
"-for i in range(1, N):",
"- a[i] = a[i - 1] + X[i][0]",
"-for j in range(N):",
"- if a[j] > X[j][1]:",
"+X = sorted(X, key=lambda x: x[1]) # B (締切の早い順にソート)",
"+res = 0",
"+for i in range(N):",
"+ res += X[i][0]",
"+ if res > X[i][1]:"
] | false | 0.036259 | 0.035402 | 1.024201 | [
"s416765949",
"s816851916"
] |
u529787332 | p03448 | python | s083926388 | s349758339 | 143 | 121 | 21,992 | 21,992 | Accepted | Accepted | 15.38 | cnt500 = int(eval(input()))
cnt100 = int(eval(input()))
cnt50 = int(eval(input()))
X = int(eval(input()))
all_set = set([])
for i,a in enumerate(range(cnt500+1)):
tmp500 = i*500
if tmp500 > X:
break
all_set.add((tmp500, 0, 0))
for i,b in enumerate(range(cnt100+1)):
tmp100 = i*100
if tmp100 > X:
break
all_set.add((tmp500, tmp100, 0))
for i,c in enumerate(range(cnt50+1)):
tmp50 = i*50
if tmp50 > X:
break
all_set.add((tmp500, tmp100, tmp50))
all = []
for a in all_set:
all.append(sum(a))
print((all.count(X))) | cnt500 = int(eval(input()))
cnt100 = int(eval(input()))
cnt50 = int(eval(input()))
X = int(eval(input()))
all_set = set([])
for a in range(cnt500+1):
tmp500 = a*500
if tmp500 > X:
break
all_set.add((tmp500, 0, 0))
for b in range(cnt100+1):
tmp100 = b*100
if tmp100 > X:
break
all_set.add((tmp500, tmp100, 0))
for c in range(cnt50+1):
tmp50 = c*50
if tmp50 > X:
break
all_set.add((tmp500, tmp100, tmp50))
all = []
for a in all_set:
all.append(sum(a))
print((all.count(X))) | 27 | 27 | 637 | 598 | cnt500 = int(eval(input()))
cnt100 = int(eval(input()))
cnt50 = int(eval(input()))
X = int(eval(input()))
all_set = set([])
for i, a in enumerate(range(cnt500 + 1)):
tmp500 = i * 500
if tmp500 > X:
break
all_set.add((tmp500, 0, 0))
for i, b in enumerate(range(cnt100 + 1)):
tmp100 = i * 100
if tmp100 > X:
break
all_set.add((tmp500, tmp100, 0))
for i, c in enumerate(range(cnt50 + 1)):
tmp50 = i * 50
if tmp50 > X:
break
all_set.add((tmp500, tmp100, tmp50))
all = []
for a in all_set:
all.append(sum(a))
print((all.count(X)))
| cnt500 = int(eval(input()))
cnt100 = int(eval(input()))
cnt50 = int(eval(input()))
X = int(eval(input()))
all_set = set([])
for a in range(cnt500 + 1):
tmp500 = a * 500
if tmp500 > X:
break
all_set.add((tmp500, 0, 0))
for b in range(cnt100 + 1):
tmp100 = b * 100
if tmp100 > X:
break
all_set.add((tmp500, tmp100, 0))
for c in range(cnt50 + 1):
tmp50 = c * 50
if tmp50 > X:
break
all_set.add((tmp500, tmp100, tmp50))
all = []
for a in all_set:
all.append(sum(a))
print((all.count(X)))
| false | 0 | [
"-for i, a in enumerate(range(cnt500 + 1)):",
"- tmp500 = i * 500",
"+for a in range(cnt500 + 1):",
"+ tmp500 = a * 500",
"- for i, b in enumerate(range(cnt100 + 1)):",
"- tmp100 = i * 100",
"+ for b in range(cnt100 + 1):",
"+ tmp100 = b * 100",
"- for i, c in enumerate(range(cnt50 + 1)):",
"- tmp50 = i * 50",
"+ for c in range(cnt50 + 1):",
"+ tmp50 = c * 50"
] | false | 0.058746 | 0.137082 | 0.428546 | [
"s083926388",
"s349758339"
] |
u867848444 | p03559 | python | s779515170 | s912886810 | 997 | 472 | 24,052 | 106,340 | Accepted | Accepted | 52.66 | n=int(eval(input()))
a=sorted(list(map(int,input().split())))
b=list(map(int,input().split()))
c=sorted(list(map(int,input().split())))
def bin_a(list,bi):
ok=-1
ng=n
while abs(ok-ng)>1:
mid=(ok+ng)//2
if bi>list[mid]:
ok=mid
else:
ng=mid
return ok+1
def bin_c(list,bi):
ok=n
ng=-1
while abs(ok-ng)>1:
mid=(ok+ng)//2
if bi<list[mid]:
ok=mid
else:
ng=mid
return n-ok
cnt=0
for i in range(n):
cnt+=bin_a(a,b[i])*bin_c(c,b[i])
#print(bin_a(a,b[i]),bin_c(c,b[i]))
print(cnt) | from bisect import *
n = int(eval(input()))
a = list(map(int,input().split()))
b = list(map(int,input().split()))
c = list(map(int,input().split()))
a = sorted(a)
c = sorted(c)
rec = 0
for i in range(n):
temp = b[i]
l = bisect_left(a, temp)
r = bisect_right(c, temp)
rec += l * (n - r)
print(rec) | 31 | 16 | 632 | 323 | n = int(eval(input()))
a = sorted(list(map(int, input().split())))
b = list(map(int, input().split()))
c = sorted(list(map(int, input().split())))
def bin_a(list, bi):
ok = -1
ng = n
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if bi > list[mid]:
ok = mid
else:
ng = mid
return ok + 1
def bin_c(list, bi):
ok = n
ng = -1
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if bi < list[mid]:
ok = mid
else:
ng = mid
return n - ok
cnt = 0
for i in range(n):
cnt += bin_a(a, b[i]) * bin_c(c, b[i])
# print(bin_a(a,b[i]),bin_c(c,b[i]))
print(cnt)
| from bisect import *
n = int(eval(input()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
a = sorted(a)
c = sorted(c)
rec = 0
for i in range(n):
temp = b[i]
l = bisect_left(a, temp)
r = bisect_right(c, temp)
rec += l * (n - r)
print(rec)
| false | 48.387097 | [
"+from bisect import *",
"+",
"-a = sorted(list(map(int, input().split())))",
"+a = list(map(int, input().split()))",
"-c = sorted(list(map(int, input().split())))",
"-",
"-",
"-def bin_a(list, bi):",
"- ok = -1",
"- ng = n",
"- while abs(ok - ng) > 1:",
"- mid = (ok + ng) // 2",
"- if bi > list[mid]:",
"- ok = mid",
"- else:",
"- ng = mid",
"- return ok + 1",
"-",
"-",
"-def bin_c(list, bi):",
"- ok = n",
"- ng = -1",
"- while abs(ok - ng) > 1:",
"- mid = (ok + ng) // 2",
"- if bi < list[mid]:",
"- ok = mid",
"- else:",
"- ng = mid",
"- return n - ok",
"-",
"-",
"-cnt = 0",
"+c = list(map(int, input().split()))",
"+a = sorted(a)",
"+c = sorted(c)",
"+rec = 0",
"- cnt += bin_a(a, b[i]) * bin_c(c, b[i])",
"- # print(bin_a(a,b[i]),bin_c(c,b[i]))",
"-print(cnt)",
"+ temp = b[i]",
"+ l = bisect_left(a, temp)",
"+ r = bisect_right(c, temp)",
"+ rec += l * (n - r)",
"+print(rec)"
] | false | 0.053633 | 0.06758 | 0.793618 | [
"s779515170",
"s912886810"
] |
u631277801 | p03688 | python | s576831075 | s132141107 | 72 | 46 | 13,304 | 13,964 | Accepted | Accepted | 36.11 | import sys
stdin = sys.stdin
def li(): return map(int, stdin.readline().split())
def li_(): return map(lambda x: int(x)-1, stdin.readline().split())
def lf(): return map(float, stdin.readline().split())
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
n = ni()
a = list(li())
exist = True
if max(a) - min(a) > 1:
exist = False
elif max(a) >= n:
exist = False
elif max(a) - min(a) == 1:
if a.count(min(a)) < max(a) and 2*(max(a)-a.count(min(a))) <= a.count(max(a)):
exist = True
else:
exist = False
elif max(a) == min(a):
if 2*a[0] <= n or a[0]+1 == n:
exist = True
else:
exist = False
print("Yes") if exist else print("No")
| n = int(eval(input()))
a = list(map(int, input().split()))
unum = min(a)
vnum = max(a)
u = a.count(unum)
v = a.count(vnum)
exist = False
if vnum-unum == 1:
if u+1 <= vnum <= u+v//2:
exist = True
elif vnum == unum:
if vnum == n-1 or vnum <= n//2:
exist = True
print(("Yes" if exist else "No"))
| 36 | 20 | 890 | 330 | import sys
stdin = sys.stdin
def li():
return map(int, stdin.readline().split())
def li_():
return map(lambda x: int(x) - 1, stdin.readline().split())
def lf():
return map(float, stdin.readline().split())
def ls():
return stdin.readline().split()
def ns():
return stdin.readline().rstrip()
def lc():
return list(ns())
def ni():
return int(stdin.readline())
def nf():
return float(stdin.readline())
n = ni()
a = list(li())
exist = True
if max(a) - min(a) > 1:
exist = False
elif max(a) >= n:
exist = False
elif max(a) - min(a) == 1:
if a.count(min(a)) < max(a) and 2 * (max(a) - a.count(min(a))) <= a.count(max(a)):
exist = True
else:
exist = False
elif max(a) == min(a):
if 2 * a[0] <= n or a[0] + 1 == n:
exist = True
else:
exist = False
print("Yes") if exist else print("No")
| n = int(eval(input()))
a = list(map(int, input().split()))
unum = min(a)
vnum = max(a)
u = a.count(unum)
v = a.count(vnum)
exist = False
if vnum - unum == 1:
if u + 1 <= vnum <= u + v // 2:
exist = True
elif vnum == unum:
if vnum == n - 1 or vnum <= n // 2:
exist = True
print(("Yes" if exist else "No"))
| false | 44.444444 | [
"-import sys",
"-",
"-stdin = sys.stdin",
"-",
"-",
"-def li():",
"- return map(int, stdin.readline().split())",
"-",
"-",
"-def li_():",
"- return map(lambda x: int(x) - 1, stdin.readline().split())",
"-",
"-",
"-def lf():",
"- return map(float, stdin.readline().split())",
"-",
"-",
"-def ls():",
"- return stdin.readline().split()",
"-",
"-",
"-def ns():",
"- return stdin.readline().rstrip()",
"-",
"-",
"-def lc():",
"- return list(ns())",
"-",
"-",
"-def ni():",
"- return int(stdin.readline())",
"-",
"-",
"-def nf():",
"- return float(stdin.readline())",
"-",
"-",
"-n = ni()",
"-a = list(li())",
"-exist = True",
"-if max(a) - min(a) > 1:",
"- exist = False",
"-elif max(a) >= n:",
"- exist = False",
"-elif max(a) - min(a) == 1:",
"- if a.count(min(a)) < max(a) and 2 * (max(a) - a.count(min(a))) <= a.count(max(a)):",
"+n = int(eval(input()))",
"+a = list(map(int, input().split()))",
"+unum = min(a)",
"+vnum = max(a)",
"+u = a.count(unum)",
"+v = a.count(vnum)",
"+exist = False",
"+if vnum - unum == 1:",
"+ if u + 1 <= vnum <= u + v // 2:",
"- else:",
"- exist = False",
"-elif max(a) == min(a):",
"- if 2 * a[0] <= n or a[0] + 1 == n:",
"+elif vnum == unum:",
"+ if vnum == n - 1 or vnum <= n // 2:",
"- else:",
"- exist = False",
"-print(\"Yes\") if exist else print(\"No\")",
"+print((\"Yes\" if exist else \"No\"))"
] | false | 0.09026 | 0.105387 | 0.856457 | [
"s576831075",
"s132141107"
] |
u270144704 | p02837 | python | s741274041 | s781046790 | 302 | 266 | 43,116 | 43,256 | Accepted | Accepted | 11.92 | n = int(eval(input()))
xy = [[] for _ in range(n)]
ans = -float("inf")
for i in range(n):
a = int(eval(input()))
for _ in range(a):
xy[i].append(tuple(map(int, input().split())))
for i in range(1 << n):
true_or_false = [0] * n
flag = False
for j in range(n):
if (i>>j)&1:
true_or_false[n-1-j] = 1
for i, l in enumerate(xy):
for x, y in l:
if true_or_false[i] == 1:
if true_or_false[x-1] != y:
flag = True
if not flag:
ans = max(ans, len([i for i in true_or_false if i == 1]))
print(ans)
| n = int(eval(input()))
xy = [[] for _ in range(n)]
ans = -float("inf")
for i in range(n):
a = int(eval(input()))
for _ in range(a):
x, y = list(map(int, input().split()))
xy[i].append(tuple([x-1, y]))
for i in range(2**n):
flag = False
cnt = 0
for j in range(n):
if (i >> j) & 1:
cnt += 1
for x, y in xy[j]:
if y == 1:
if (i >> x & 1) == 0:
flag = True
elif y == 0:
if (i >> x & 1) == 1:
flag = True
if not flag:
ans = max(ans, cnt)
print(ans) | 23 | 26 | 529 | 502 | n = int(eval(input()))
xy = [[] for _ in range(n)]
ans = -float("inf")
for i in range(n):
a = int(eval(input()))
for _ in range(a):
xy[i].append(tuple(map(int, input().split())))
for i in range(1 << n):
true_or_false = [0] * n
flag = False
for j in range(n):
if (i >> j) & 1:
true_or_false[n - 1 - j] = 1
for i, l in enumerate(xy):
for x, y in l:
if true_or_false[i] == 1:
if true_or_false[x - 1] != y:
flag = True
if not flag:
ans = max(ans, len([i for i in true_or_false if i == 1]))
print(ans)
| n = int(eval(input()))
xy = [[] for _ in range(n)]
ans = -float("inf")
for i in range(n):
a = int(eval(input()))
for _ in range(a):
x, y = list(map(int, input().split()))
xy[i].append(tuple([x - 1, y]))
for i in range(2**n):
flag = False
cnt = 0
for j in range(n):
if (i >> j) & 1:
cnt += 1
for x, y in xy[j]:
if y == 1:
if (i >> x & 1) == 0:
flag = True
elif y == 0:
if (i >> x & 1) == 1:
flag = True
if not flag:
ans = max(ans, cnt)
print(ans)
| false | 11.538462 | [
"- xy[i].append(tuple(map(int, input().split())))",
"-for i in range(1 << n):",
"- true_or_false = [0] * n",
"+ x, y = list(map(int, input().split()))",
"+ xy[i].append(tuple([x - 1, y]))",
"+for i in range(2**n):",
"+ cnt = 0",
"- true_or_false[n - 1 - j] = 1",
"- for i, l in enumerate(xy):",
"- for x, y in l:",
"- if true_or_false[i] == 1:",
"- if true_or_false[x - 1] != y:",
"- flag = True",
"+ cnt += 1",
"+ for x, y in xy[j]:",
"+ if y == 1:",
"+ if (i >> x & 1) == 0:",
"+ flag = True",
"+ elif y == 0:",
"+ if (i >> x & 1) == 1:",
"+ flag = True",
"- ans = max(ans, len([i for i in true_or_false if i == 1]))",
"+ ans = max(ans, cnt)"
] | false | 0.080962 | 0.135625 | 0.596958 | [
"s741274041",
"s781046790"
] |
u558242240 | p03164 | python | s835165701 | s773975872 | 322 | 290 | 43,332 | 41,452 | Accepted | Accepted | 9.94 | n, w = list(map(int, input().split()))
wv = [tuple(map(int, input().split())) for _ in range(n)]
INF = 10**9 + 100
MAX_V = 10**5 + 100
dp = [INF] * (MAX_V + 1)
dp[0] = 0
for wi, vi in wv:
for sum_v in reversed(list(range(vi, MAX_V+1))):
dp[sum_v] = min(dp[sum_v - vi] + wi, dp[sum_v])
#print(dp)
ans = 0
for i in range(MAX_V, -1, -1):
if dp[i] <= w:
print(i)
exit()
#print(ans)
| n, w = list(map(int, input().split()))
wv = [tuple(map(int, input().split())) for _ in range(n)]
INF = 10**9 + 100
MAX_V = 10**5 + 100
dp = [INF] * (MAX_V + 1)
dp[0] = 0
for wi, vi in wv:
for sum_v in reversed(list(range(vi, MAX_V+1))):
dp[sum_v] = min(dp[sum_v - vi] + wi, dp[sum_v])
#print(dp)
ans = 0
for i in reversed(list(range(MAX_V+1))):
if dp[i] <= w:
print(i)
exit()
#print(ans)
| 17 | 17 | 415 | 419 | n, w = list(map(int, input().split()))
wv = [tuple(map(int, input().split())) for _ in range(n)]
INF = 10**9 + 100
MAX_V = 10**5 + 100
dp = [INF] * (MAX_V + 1)
dp[0] = 0
for wi, vi in wv:
for sum_v in reversed(list(range(vi, MAX_V + 1))):
dp[sum_v] = min(dp[sum_v - vi] + wi, dp[sum_v])
# print(dp)
ans = 0
for i in range(MAX_V, -1, -1):
if dp[i] <= w:
print(i)
exit()
# print(ans)
| n, w = list(map(int, input().split()))
wv = [tuple(map(int, input().split())) for _ in range(n)]
INF = 10**9 + 100
MAX_V = 10**5 + 100
dp = [INF] * (MAX_V + 1)
dp[0] = 0
for wi, vi in wv:
for sum_v in reversed(list(range(vi, MAX_V + 1))):
dp[sum_v] = min(dp[sum_v - vi] + wi, dp[sum_v])
# print(dp)
ans = 0
for i in reversed(list(range(MAX_V + 1))):
if dp[i] <= w:
print(i)
exit()
# print(ans)
| false | 0 | [
"-for i in range(MAX_V, -1, -1):",
"+for i in reversed(list(range(MAX_V + 1))):"
] | false | 0.219043 | 0.258083 | 0.84873 | [
"s835165701",
"s773975872"
] |
u186838327 | p02744 | python | s025663026 | s201596120 | 347 | 135 | 61,020 | 83,264 | Accepted | Accepted | 61.1 | n = int(eval(input()))
L = [0]*n
for i in range(n):
L[i] = chr(i+ord('a'))
#print(L)_
ans = []
def dfs(A):
if len(A) == n:
ans.append(''.join(A))
return
for v in L[0:len(set(A))+1]:
A.append(v)
dfs(A)
A.pop()
dfs([])
ans.sort()
for i in range(len(ans)):
print((ans[i]))
| n = int(eval(input()))
ans = []
def dfs(A):
if len(A) == n:
ans.append(''.join(A))
return
for i in range(len(set(A))+1):
v = chr(i+ord('a'))
A.append(v)
dfs(A)
A.pop()
dfs([])
ans.sort()
for i in range(len(ans)):
print((ans[i]))
| 21 | 17 | 341 | 299 | n = int(eval(input()))
L = [0] * n
for i in range(n):
L[i] = chr(i + ord("a"))
# print(L)_
ans = []
def dfs(A):
if len(A) == n:
ans.append("".join(A))
return
for v in L[0 : len(set(A)) + 1]:
A.append(v)
dfs(A)
A.pop()
dfs([])
ans.sort()
for i in range(len(ans)):
print((ans[i]))
| n = int(eval(input()))
ans = []
def dfs(A):
if len(A) == n:
ans.append("".join(A))
return
for i in range(len(set(A)) + 1):
v = chr(i + ord("a"))
A.append(v)
dfs(A)
A.pop()
dfs([])
ans.sort()
for i in range(len(ans)):
print((ans[i]))
| false | 19.047619 | [
"-L = [0] * n",
"-for i in range(n):",
"- L[i] = chr(i + ord(\"a\"))",
"-# print(L)_",
"- for v in L[0 : len(set(A)) + 1]:",
"+ for i in range(len(set(A)) + 1):",
"+ v = chr(i + ord(\"a\"))"
] | false | 0.043095 | 0.042447 | 1.015275 | [
"s025663026",
"s201596120"
] |
u779805689 | p03151 | python | s773941454 | s909955898 | 693 | 229 | 97,808 | 97,576 | Accepted | Accepted | 66.96 | import sys
N=int(eval(input()))
A=list(map(int,input().split()))
B=list(map(int,input().split()))
if sum(A)<=sum(B):
print((-1))
sys.exit()
Y=0
K=0
Q=[]
for i in range(N):
k=A[i]-B[i]
if k>0:
Q.append(k)
elif k<0:
K+=1
Y+=-k
Q.sort(reverse=True)
while Y>0:
q=Q.pop(0)
Y-=q
K+=1
print(K)
| import sys
N=int(eval(input()))
A=list(map(int,input().split()))
B=list(map(int,input().split()))
if sum(A)<=sum(B):
print((-1))
sys.exit()
Y=0
K=0
Q=[]
for i in range(N):
k=A[i]-B[i]
if k>0:
Q.append(k)
elif k<0:
K+=1
Y+=-k
Q.sort()
while Y>0:
q=Q.pop()
Y-=q
K+=1
print(K)
| 30 | 30 | 375 | 362 | import sys
N = int(eval(input()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
if sum(A) <= sum(B):
print((-1))
sys.exit()
Y = 0
K = 0
Q = []
for i in range(N):
k = A[i] - B[i]
if k > 0:
Q.append(k)
elif k < 0:
K += 1
Y += -k
Q.sort(reverse=True)
while Y > 0:
q = Q.pop(0)
Y -= q
K += 1
print(K)
| import sys
N = int(eval(input()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
if sum(A) <= sum(B):
print((-1))
sys.exit()
Y = 0
K = 0
Q = []
for i in range(N):
k = A[i] - B[i]
if k > 0:
Q.append(k)
elif k < 0:
K += 1
Y += -k
Q.sort()
while Y > 0:
q = Q.pop()
Y -= q
K += 1
print(K)
| false | 0 | [
"-Q.sort(reverse=True)",
"+Q.sort()",
"- q = Q.pop(0)",
"+ q = Q.pop()"
] | false | 0.043033 | 0.041642 | 1.033389 | [
"s773941454",
"s909955898"
] |
u638033979 | p02702 | python | s931547212 | s002085092 | 330 | 119 | 9,324 | 10,920 | Accepted | Accepted | 63.94 | S=eval(input())
N=len(S)
M=2019
remainder=[0]*M
val=0
for i in range(N):
val=(int(S[N-1-i])*pow(10,i,M)+val)%M
remainder[val]+=1
ans=remainder[0]
for i in range(2019):
ans+=remainder[i]*(remainder[i]-1)//2
print(ans) | from collections import deque
s = deque(eval(input()))
n = len(s)
temp = [0]*2019
t = 1
num = 0
for i in range(n):
num += int(s.pop())*t
temp[num % 2019] += 1
t = t*10 % 2019
ans = temp[0]
for t in temp:
if t > 1:
ans += t*(t-1)/2
print((int(ans))) | 14 | 18 | 231 | 286 | S = eval(input())
N = len(S)
M = 2019
remainder = [0] * M
val = 0
for i in range(N):
val = (int(S[N - 1 - i]) * pow(10, i, M) + val) % M
remainder[val] += 1
ans = remainder[0]
for i in range(2019):
ans += remainder[i] * (remainder[i] - 1) // 2
print(ans)
| from collections import deque
s = deque(eval(input()))
n = len(s)
temp = [0] * 2019
t = 1
num = 0
for i in range(n):
num += int(s.pop()) * t
temp[num % 2019] += 1
t = t * 10 % 2019
ans = temp[0]
for t in temp:
if t > 1:
ans += t * (t - 1) / 2
print((int(ans)))
| false | 22.222222 | [
"-S = eval(input())",
"-N = len(S)",
"-M = 2019",
"-remainder = [0] * M",
"-val = 0",
"-for i in range(N):",
"- val = (int(S[N - 1 - i]) * pow(10, i, M) + val) % M",
"- remainder[val] += 1",
"-ans = remainder[0]",
"-for i in range(2019):",
"- ans += remainder[i] * (remainder[i] - 1) // 2",
"-print(ans)",
"+from collections import deque",
"+",
"+s = deque(eval(input()))",
"+n = len(s)",
"+temp = [0] * 2019",
"+t = 1",
"+num = 0",
"+for i in range(n):",
"+ num += int(s.pop()) * t",
"+ temp[num % 2019] += 1",
"+ t = t * 10 % 2019",
"+ans = temp[0]",
"+for t in temp:",
"+ if t > 1:",
"+ ans += t * (t - 1) / 2",
"+print((int(ans)))"
] | false | 0.036157 | 0.0354 | 1.021381 | [
"s931547212",
"s002085092"
] |
u179169725 | p02788 | python | s347201764 | s672519725 | 1,120 | 977 | 48,636 | 48,656 | Accepted | Accepted | 12.77 | # https://atcoder.jp/contests/abc153/tasks/abc153_f
# 座標圧縮、貪欲法、imos法
import sys
read = sys.stdin.readline
def read_ints():
return list(map(int, read().split()))
def read_tuple(H):
'''
H is number of rows
'''
ret = []
for _ in range(H):
ret.append(tuple(map(int, read().split())))
return ret
# まず、何回攻撃すればいいのかを計算する。これがとにかく必要だ(なくてもいいけど)。
#
# 素直な戦略として、左から倒せるギリギリの爆弾を投下して倒すのが最適
# だけどナイーブに実装すると、O(N^2)。だから体力を管理するのが重要。
# どこにどれだけダメージが蓄積したのかはimos法(デルタ関数をおいてから累積和)で管理できる。
from bisect import bisect_left
N, D, A = read_ints()
XH = read_tuple(N)
XH.sort() # 座標でソート
n_atk = [] # 何回攻撃するのが必要か
X = [] # 座標アクセス用配列
for x, h in XH:
n_atk.append((h - 1) // A + 1)
X.append(x)
damege = [0] * (N + 10) # ダメージ管理用、配列外アクセスがめんどくさいので長めに取る
ans = 0
# j = 0 # 次のxが、今のx+2d以下でもっとも大きなidx
for i, (x, n) in enumerate(zip(X, n_atk)):
damege[i] += damege[i - 1] # 積分して、現時点の蓄積回数を表示
atk = max(0, n - damege[i]) # iには何回攻撃したか
if atk == 0:
continue
ans += atk
# 攻撃下回数を記録
damege[i] += atk
# 効果が切れる点を予約 # 尺取ならO(1)で次に行けるけど二分探索でも間に合うか
# while j < len(X) and X[j] < x + 2 * D + 1: # あんま高速化しないね
# j += 1
# damege[j] -= atk # 効果切れを予約
damege[bisect_left(X, x + 2 * D + 1, lo=i)] -= atk # 二分探索で十分速い
print(ans)
| # https://atcoder.jp/contests/abc153/tasks/abc153_f
# 座標圧縮、貪欲法、imos法
import sys
read = sys.stdin.readline
def read_ints():
return list(map(int, read().split()))
def read_tuple(H):
'''
H is number of rows
'''
ret = []
for _ in range(H):
ret.append(tuple(map(int, read().split())))
return ret
# まず、何回攻撃すればいいのかを計算する。これがとにかく必要だ(なくてもいいけど)。
#
# 素直な戦略として、左から倒せるギリギリの爆弾を投下して倒すのが最適
# だけどナイーブに実装すると、O(N^2)。だから体力を管理するのが重要。
# どこにどれだけダメージが蓄積したのかはimos法(デルタ関数をおいてから累積和)で管理できる。
from bisect import bisect_left
def main():
N, D, A = read_ints()
XH = read_tuple(N)
XH.sort() # 座標でソート
n_atk = [] # 何回攻撃するのが必要か
X = [] # 座標アクセス用配列
for x, h in XH:
n_atk.append((h - 1) // A + 1)
X.append(x)
damege = [0] * (N + 10) # ダメージ管理用、配列外アクセスがめんどくさいので長めに取る
ans = 0
# j = 0 # 次のxが、今のx+2d以下でもっとも大きなidx
for i, (x, n) in enumerate(zip(X, n_atk)):
damege[i] += damege[i - 1] # 積分して、現時点の蓄積回数を表示
atk = max(0, n - damege[i]) # iには何回攻撃したか
ans += atk
# 攻撃下回数を記録
damege[i] += atk
# 効果が切れる点を予約 # 尺取ならO(1)で次に行けるけど二分探索でも間に合うか
# while j < len(X) and X[j] < x + 2 * D + 1: # あんま高速化しないね
# j += 1
# damege[j] -= atk # 効果切れを予約
damege[bisect_left(X, x + 2 * D + 1, lo=i)] -= atk # 二分探索で十分速い
print(ans)
if __name__ == "__main__":
main()
| 58 | 62 | 1,339 | 1,454 | # https://atcoder.jp/contests/abc153/tasks/abc153_f
# 座標圧縮、貪欲法、imos法
import sys
read = sys.stdin.readline
def read_ints():
return list(map(int, read().split()))
def read_tuple(H):
"""
H is number of rows
"""
ret = []
for _ in range(H):
ret.append(tuple(map(int, read().split())))
return ret
# まず、何回攻撃すればいいのかを計算する。これがとにかく必要だ(なくてもいいけど)。
#
# 素直な戦略として、左から倒せるギリギリの爆弾を投下して倒すのが最適
# だけどナイーブに実装すると、O(N^2)。だから体力を管理するのが重要。
# どこにどれだけダメージが蓄積したのかはimos法(デルタ関数をおいてから累積和)で管理できる。
from bisect import bisect_left
N, D, A = read_ints()
XH = read_tuple(N)
XH.sort() # 座標でソート
n_atk = [] # 何回攻撃するのが必要か
X = [] # 座標アクセス用配列
for x, h in XH:
n_atk.append((h - 1) // A + 1)
X.append(x)
damege = [0] * (N + 10) # ダメージ管理用、配列外アクセスがめんどくさいので長めに取る
ans = 0
# j = 0 # 次のxが、今のx+2d以下でもっとも大きなidx
for i, (x, n) in enumerate(zip(X, n_atk)):
damege[i] += damege[i - 1] # 積分して、現時点の蓄積回数を表示
atk = max(0, n - damege[i]) # iには何回攻撃したか
if atk == 0:
continue
ans += atk
# 攻撃下回数を記録
damege[i] += atk
# 効果が切れる点を予約 # 尺取ならO(1)で次に行けるけど二分探索でも間に合うか
# while j < len(X) and X[j] < x + 2 * D + 1: # あんま高速化しないね
# j += 1
# damege[j] -= atk # 効果切れを予約
damege[bisect_left(X, x + 2 * D + 1, lo=i)] -= atk # 二分探索で十分速い
print(ans)
| # https://atcoder.jp/contests/abc153/tasks/abc153_f
# 座標圧縮、貪欲法、imos法
import sys
read = sys.stdin.readline
def read_ints():
return list(map(int, read().split()))
def read_tuple(H):
"""
H is number of rows
"""
ret = []
for _ in range(H):
ret.append(tuple(map(int, read().split())))
return ret
# まず、何回攻撃すればいいのかを計算する。これがとにかく必要だ(なくてもいいけど)。
#
# 素直な戦略として、左から倒せるギリギリの爆弾を投下して倒すのが最適
# だけどナイーブに実装すると、O(N^2)。だから体力を管理するのが重要。
# どこにどれだけダメージが蓄積したのかはimos法(デルタ関数をおいてから累積和)で管理できる。
from bisect import bisect_left
def main():
N, D, A = read_ints()
XH = read_tuple(N)
XH.sort() # 座標でソート
n_atk = [] # 何回攻撃するのが必要か
X = [] # 座標アクセス用配列
for x, h in XH:
n_atk.append((h - 1) // A + 1)
X.append(x)
damege = [0] * (N + 10) # ダメージ管理用、配列外アクセスがめんどくさいので長めに取る
ans = 0
# j = 0 # 次のxが、今のx+2d以下でもっとも大きなidx
for i, (x, n) in enumerate(zip(X, n_atk)):
damege[i] += damege[i - 1] # 積分して、現時点の蓄積回数を表示
atk = max(0, n - damege[i]) # iには何回攻撃したか
ans += atk
# 攻撃下回数を記録
damege[i] += atk
# 効果が切れる点を予約 # 尺取ならO(1)で次に行けるけど二分探索でも間に合うか
# while j < len(X) and X[j] < x + 2 * D + 1: # あんま高速化しないね
# j += 1
# damege[j] -= atk # 効果切れを予約
damege[bisect_left(X, x + 2 * D + 1, lo=i)] -= atk # 二分探索で十分速い
print(ans)
if __name__ == "__main__":
main()
| false | 6.451613 | [
"-N, D, A = read_ints()",
"-XH = read_tuple(N)",
"-XH.sort() # 座標でソート",
"-n_atk = [] # 何回攻撃するのが必要か",
"-X = [] # 座標アクセス用配列",
"-for x, h in XH:",
"- n_atk.append((h - 1) // A + 1)",
"- X.append(x)",
"-damege = [0] * (N + 10) # ダメージ管理用、配列外アクセスがめんどくさいので長めに取る",
"-ans = 0",
"-# j = 0 # 次のxが、今のx+2d以下でもっとも大きなidx",
"-for i, (x, n) in enumerate(zip(X, n_atk)):",
"- damege[i] += damege[i - 1] # 積分して、現時点の蓄積回数を表示",
"- atk = max(0, n - damege[i]) # iには何回攻撃したか",
"- if atk == 0:",
"- continue",
"- ans += atk",
"- # 攻撃下回数を記録",
"- damege[i] += atk",
"- # 効果が切れる点を予約 # 尺取ならO(1)で次に行けるけど二分探索でも間に合うか",
"- # while j < len(X) and X[j] < x + 2 * D + 1: # あんま高速化しないね",
"- # j += 1",
"- # damege[j] -= atk # 効果切れを予約",
"- damege[bisect_left(X, x + 2 * D + 1, lo=i)] -= atk # 二分探索で十分速い",
"-print(ans)",
"+",
"+def main():",
"+ N, D, A = read_ints()",
"+ XH = read_tuple(N)",
"+ XH.sort() # 座標でソート",
"+ n_atk = [] # 何回攻撃するのが必要か",
"+ X = [] # 座標アクセス用配列",
"+ for x, h in XH:",
"+ n_atk.append((h - 1) // A + 1)",
"+ X.append(x)",
"+ damege = [0] * (N + 10) # ダメージ管理用、配列外アクセスがめんどくさいので長めに取る",
"+ ans = 0",
"+ # j = 0 # 次のxが、今のx+2d以下でもっとも大きなidx",
"+ for i, (x, n) in enumerate(zip(X, n_atk)):",
"+ damege[i] += damege[i - 1] # 積分して、現時点の蓄積回数を表示",
"+ atk = max(0, n - damege[i]) # iには何回攻撃したか",
"+ ans += atk",
"+ # 攻撃下回数を記録",
"+ damege[i] += atk",
"+ # 効果が切れる点を予約 # 尺取ならO(1)で次に行けるけど二分探索でも間に合うか",
"+ # while j < len(X) and X[j] < x + 2 * D + 1: # あんま高速化しないね",
"+ # j += 1",
"+ # damege[j] -= atk # 効果切れを予約",
"+ damege[bisect_left(X, x + 2 * D + 1, lo=i)] -= atk # 二分探索で十分速い",
"+ print(ans)",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false | 0.036996 | 0.045374 | 0.815344 | [
"s347201764",
"s672519725"
] |
u987164499 | p03555 | python | s827099892 | s560161145 | 158 | 17 | 12,052 | 2,940 | Accepted | Accepted | 89.24 | from sys import stdin
import math
import bisect
import heapq
import numpy as np
from math import factorial
s = stdin.readline().rstrip()
t = stdin.readline().rstrip()
if s[::-1] == t:
print("YES")
else:
print("NO") | from sys import stdin
from sys import setrecursionlimit
setrecursionlimit(10 ** 7)
s = eval(input())
t = input()[::-1]
if s == t:
print("YES")
else:
print("NO") | 14 | 11 | 237 | 174 | from sys import stdin
import math
import bisect
import heapq
import numpy as np
from math import factorial
s = stdin.readline().rstrip()
t = stdin.readline().rstrip()
if s[::-1] == t:
print("YES")
else:
print("NO")
| from sys import stdin
from sys import setrecursionlimit
setrecursionlimit(10**7)
s = eval(input())
t = input()[::-1]
if s == t:
print("YES")
else:
print("NO")
| false | 21.428571 | [
"-import math",
"-import bisect",
"-import heapq",
"-import numpy as np",
"-from math import factorial",
"+from sys import setrecursionlimit",
"-s = stdin.readline().rstrip()",
"-t = stdin.readline().rstrip()",
"-if s[::-1] == t:",
"+setrecursionlimit(10**7)",
"+s = eval(input())",
"+t = input()[::-1]",
"+if s == t:"
] | false | 0.12351 | 0.044526 | 2.77385 | [
"s827099892",
"s560161145"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.