user_id
stringlengths 10
10
| problem_id
stringlengths 6
6
| language
stringclasses 1
value | submission_id_v0
stringlengths 10
10
| submission_id_v1
stringlengths 10
10
| cpu_time_v0
int64 10
38.3k
| cpu_time_v1
int64 0
24.7k
| memory_v0
int64 2.57k
1.02M
| memory_v1
int64 2.57k
869k
| status_v0
stringclasses 1
value | status_v1
stringclasses 1
value | improvement_frac
float64 7.51
100
| input
stringlengths 20
4.55k
| target
stringlengths 17
3.34k
| code_v0_loc
int64 1
148
| code_v1_loc
int64 1
184
| code_v0_num_chars
int64 13
4.55k
| code_v1_num_chars
int64 14
3.34k
| code_v0_no_empty_lines
stringlengths 21
6.88k
| code_v1_no_empty_lines
stringlengths 20
4.93k
| code_same
bool 1
class | relative_loc_diff_percent
float64 0
79.8
| diff
list | diff_only_import_comment
bool 1
class | measured_runtime_v0
float64 0.01
4.45
| measured_runtime_v1
float64 0.01
4.31
| runtime_lift
float64 0
359
| key
list |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
u079022693 | p02833 | python | s920348303 | s486464948 | 170 | 17 | 38,384 | 3,060 | Accepted | Accepted | 90 | N=int(eval(input()))
if N%2==0:
cou=0
i=1
while(N>=(2*5**i)):
cou+=N//(2*5**i)
i+=1
print(cou)
elif N%2==1:
print((0)) | from sys import stdin
from sys import exit
def main():
#入力
readline=stdin.readline
n=int(readline())
if n%2==1:
print((0))
exit()
n//=2
ans=0
x=5
while n//x>=1:
ans+=n//x
x*=5
print(ans)
if __name__=="__main__":
main() | 12 | 22 | 141 | 317 | N = int(eval(input()))
if N % 2 == 0:
cou = 0
i = 1
while N >= (2 * 5**i):
cou += N // (2 * 5**i)
i += 1
print(cou)
elif N % 2 == 1:
print((0))
| from sys import stdin
from sys import exit
def main():
# 入力
readline = stdin.readline
n = int(readline())
if n % 2 == 1:
print((0))
exit()
n //= 2
ans = 0
x = 5
while n // x >= 1:
ans += n // x
x *= 5
print(ans)
if __name__ == "__main__":
main()
| false | 45.454545 | [
"-N = int(eval(input()))",
"-if N % 2 == 0:",
"- cou = 0",
"- i = 1",
"- while N >= (2 * 5**i):",
"- cou += N // (2 * 5**i)",
"- i += 1",
"- print(cou)",
"-elif N % 2 == 1:",
"- print((0))",
"+from sys import stdin",
"+from sys import exit",
"+",
"+",
"+def main():",
"+ # 入力",
"+ readline = stdin.readline",
"+ n = int(readline())",
"+ if n % 2 == 1:",
"+ print((0))",
"+ exit()",
"+ n //= 2",
"+ ans = 0",
"+ x = 5",
"+ while n // x >= 1:",
"+ ans += n // x",
"+ x *= 5",
"+ print(ans)",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
]
| false | 0.042542 | 0.043774 | 0.971852 | [
"s920348303",
"s486464948"
]
|
u690536347 | p03861 | python | s028688504 | s652342392 | 204 | 179 | 38,512 | 38,256 | Accepted | Accepted | 12.25 | f=lambda n,x:0 if n==-1 else n//x+1
a,b,x=list(map(int,input().split()))
print((f(b,x)-f(a-1,x))) | a,b,x=list(map(int,input().split()))
f=lambda n:0 if n<0 else n//x+1
print((f(b)-f(a-1))) | 3 | 3 | 91 | 83 | f = lambda n, x: 0 if n == -1 else n // x + 1
a, b, x = list(map(int, input().split()))
print((f(b, x) - f(a - 1, x)))
| a, b, x = list(map(int, input().split()))
f = lambda n: 0 if n < 0 else n // x + 1
print((f(b) - f(a - 1)))
| false | 0 | [
"-f = lambda n, x: 0 if n == -1 else n // x + 1",
"-print((f(b, x) - f(a - 1, x)))",
"+f = lambda n: 0 if n < 0 else n // x + 1",
"+print((f(b) - f(a - 1)))"
]
| false | 0.043562 | 0.044263 | 0.984158 | [
"s028688504",
"s652342392"
]
|
u531599639 | p02971 | python | s364642932 | s666911752 | 426 | 351 | 19,192 | 18,988 | Accepted | Accepted | 17.61 | import copy
n = int(eval(input()))
a = [int(eval(input())) for _ in range(n)]
b = copy.deepcopy(a)
a.sort(reverse=True)
for v in b:
if v==a[0]:
print((a[1]))
else:
print((a[0])) | n = int(eval(input()))
a = [int(eval(input())) for _ in range(n)]
b = sorted(a)
for v in a:
print((b[(v<b[-1])-2])) | 10 | 5 | 182 | 107 | import copy
n = int(eval(input()))
a = [int(eval(input())) for _ in range(n)]
b = copy.deepcopy(a)
a.sort(reverse=True)
for v in b:
if v == a[0]:
print((a[1]))
else:
print((a[0]))
| n = int(eval(input()))
a = [int(eval(input())) for _ in range(n)]
b = sorted(a)
for v in a:
print((b[(v < b[-1]) - 2]))
| false | 50 | [
"-import copy",
"-",
"-b = copy.deepcopy(a)",
"-a.sort(reverse=True)",
"-for v in b:",
"- if v == a[0]:",
"- print((a[1]))",
"- else:",
"- print((a[0]))",
"+b = sorted(a)",
"+for v in a:",
"+ print((b[(v < b[-1]) - 2]))"
]
| false | 0.03767 | 0.035981 | 1.046957 | [
"s364642932",
"s666911752"
]
|
u633255271 | p02579 | python | s639667204 | s780938117 | 1,574 | 1,146 | 134,848 | 255,620 | Accepted | Accepted | 27.19 | from collections import deque
H, W = list(map(int, input().split()))
Ch, Cw = list([int(x) - 1 for x in input().split()])
Dh, Dw = list([int(x) - 1 for x in input().split()])
S = [eval(input()) for _ in range(H)]
def walk(i, j):
ans = []
for h, w in [[i+1, j], [i-1, j], [i, j+1], [i, j-1]]:
# print(h, w)
if h >= 0 and w >= 0 and h < H and w < W:
# print('hoen')
if S[h][w] == '.':
if maze[h][w] == -1:
ans.append((h, w))
return ans
def warp(i, j):
tmp = []
for dh in range(-2, 3):
for dw in range(-2, 3):
if not (dh == 0 and dw == 0):
tmp.append([i + dh, j + dw])
ans = []
for h, w in tmp:
if h >= 0 and w >= 0 and h < H and w < W:
if S[h][w] == '.':
if maze[h][w] == -1:
ans.append((h, w))
return ans
maze = [[-1]*W for _ in range(H)]
warp_n = 0
maze[Ch][Cw] = 0
walk_stack= deque(walk(Ch, Cw))
warp_set = set(warp(Ch, Cw))
# print(walk(Ch, Cw))
# print(warp(Ch, Cw))
# print('-----')
while walk_stack or warp_set:
while walk_stack:
h, w = walk_stack.pop()
if maze[h][w] == -1:
maze[h][w] = warp_n
walk_stack.extend(walk(h, w))
warp_set |= set(warp(h, w))
warp_n += 1
# print(*maze, sep='\n')
# print('-----')
next_warp = set()
for h, w in warp_set:
if maze[h][w] == -1:
maze[h][w] = warp_n
walk_stack.extend(walk(h, w))
next_warp |= set(warp(h, w))
warp_set = next_warp
print((maze[Dh][Dw])) | from collections import deque
H, W = list(map(int, input().split()))
Ch, Cw = list([int(x) - 1 for x in input().split()])
Dh, Dw = list([int(x) - 1 for x in input().split()])
S = [eval(input()) for _ in range(H)]
maze = [[-1]*W for _ in range(H)]
def walk(h, w, warp_n):
ans = []
if maze[h][w] != -1:
return []
else:
maze[h][w] = warp_n
ans += [(h, w)]
return ans
queue = deque([(Ch, Cw, 0)])
while queue:
h, w, warp_n = queue.popleft()
if maze[h][w] != -1:
continue
maze[h][w] = warp_n
# walk
for dh, dw in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
if h+dh < 0 or w+dw < 0 or h+dh >= H or w+dw >= W:
continue
if S[h+dh][w+dw] == '#':
continue
queue.appendleft((h+dh, w+dw, warp_n))
# warp
for dh in range(-2, 3):
for dw in range(-2, 3):
if h+dh < 0 or w+dw < 0 or h+dh >= H or w+dw >= W:
continue
if S[h+dh][w+dw] == '#':
continue
if dh == 0 and dw == 0:
continue
queue.append((h+dh, w+dw, warp_n+1))
print((maze[Dh][Dw])) | 58 | 43 | 1,682 | 1,222 | from collections import deque
H, W = list(map(int, input().split()))
Ch, Cw = list([int(x) - 1 for x in input().split()])
Dh, Dw = list([int(x) - 1 for x in input().split()])
S = [eval(input()) for _ in range(H)]
def walk(i, j):
ans = []
for h, w in [[i + 1, j], [i - 1, j], [i, j + 1], [i, j - 1]]:
# print(h, w)
if h >= 0 and w >= 0 and h < H and w < W:
# print('hoen')
if S[h][w] == ".":
if maze[h][w] == -1:
ans.append((h, w))
return ans
def warp(i, j):
tmp = []
for dh in range(-2, 3):
for dw in range(-2, 3):
if not (dh == 0 and dw == 0):
tmp.append([i + dh, j + dw])
ans = []
for h, w in tmp:
if h >= 0 and w >= 0 and h < H and w < W:
if S[h][w] == ".":
if maze[h][w] == -1:
ans.append((h, w))
return ans
maze = [[-1] * W for _ in range(H)]
warp_n = 0
maze[Ch][Cw] = 0
walk_stack = deque(walk(Ch, Cw))
warp_set = set(warp(Ch, Cw))
# print(walk(Ch, Cw))
# print(warp(Ch, Cw))
# print('-----')
while walk_stack or warp_set:
while walk_stack:
h, w = walk_stack.pop()
if maze[h][w] == -1:
maze[h][w] = warp_n
walk_stack.extend(walk(h, w))
warp_set |= set(warp(h, w))
warp_n += 1
# print(*maze, sep='\n')
# print('-----')
next_warp = set()
for h, w in warp_set:
if maze[h][w] == -1:
maze[h][w] = warp_n
walk_stack.extend(walk(h, w))
next_warp |= set(warp(h, w))
warp_set = next_warp
print((maze[Dh][Dw]))
| from collections import deque
H, W = list(map(int, input().split()))
Ch, Cw = list([int(x) - 1 for x in input().split()])
Dh, Dw = list([int(x) - 1 for x in input().split()])
S = [eval(input()) for _ in range(H)]
maze = [[-1] * W for _ in range(H)]
def walk(h, w, warp_n):
ans = []
if maze[h][w] != -1:
return []
else:
maze[h][w] = warp_n
ans += [(h, w)]
return ans
queue = deque([(Ch, Cw, 0)])
while queue:
h, w, warp_n = queue.popleft()
if maze[h][w] != -1:
continue
maze[h][w] = warp_n
# walk
for dh, dw in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
if h + dh < 0 or w + dw < 0 or h + dh >= H or w + dw >= W:
continue
if S[h + dh][w + dw] == "#":
continue
queue.appendleft((h + dh, w + dw, warp_n))
# warp
for dh in range(-2, 3):
for dw in range(-2, 3):
if h + dh < 0 or w + dw < 0 or h + dh >= H or w + dw >= W:
continue
if S[h + dh][w + dw] == "#":
continue
if dh == 0 and dw == 0:
continue
queue.append((h + dh, w + dw, warp_n + 1))
print((maze[Dh][Dw]))
| false | 25.862069 | [
"+maze = [[-1] * W for _ in range(H)]",
"-def walk(i, j):",
"+def walk(h, w, warp_n):",
"- for h, w in [[i + 1, j], [i - 1, j], [i, j + 1], [i, j - 1]]:",
"- # print(h, w)",
"- if h >= 0 and w >= 0 and h < H and w < W:",
"- # print('hoen')",
"- if S[h][w] == \".\":",
"- if maze[h][w] == -1:",
"- ans.append((h, w))",
"+ if maze[h][w] != -1:",
"+ return []",
"+ else:",
"+ maze[h][w] = warp_n",
"+ ans += [(h, w)]",
"-def warp(i, j):",
"- tmp = []",
"+queue = deque([(Ch, Cw, 0)])",
"+while queue:",
"+ h, w, warp_n = queue.popleft()",
"+ if maze[h][w] != -1:",
"+ continue",
"+ maze[h][w] = warp_n",
"+ # walk",
"+ for dh, dw in [(-1, 0), (1, 0), (0, -1), (0, 1)]:",
"+ if h + dh < 0 or w + dw < 0 or h + dh >= H or w + dw >= W:",
"+ continue",
"+ if S[h + dh][w + dw] == \"#\":",
"+ continue",
"+ queue.appendleft((h + dh, w + dw, warp_n))",
"+ # warp",
"- if not (dh == 0 and dw == 0):",
"- tmp.append([i + dh, j + dw])",
"- ans = []",
"- for h, w in tmp:",
"- if h >= 0 and w >= 0 and h < H and w < W:",
"- if S[h][w] == \".\":",
"- if maze[h][w] == -1:",
"- ans.append((h, w))",
"- return ans",
"-",
"-",
"-maze = [[-1] * W for _ in range(H)]",
"-warp_n = 0",
"-maze[Ch][Cw] = 0",
"-walk_stack = deque(walk(Ch, Cw))",
"-warp_set = set(warp(Ch, Cw))",
"-# print(walk(Ch, Cw))",
"-# print(warp(Ch, Cw))",
"-while walk_stack or warp_set:",
"- while walk_stack:",
"- h, w = walk_stack.pop()",
"- if maze[h][w] == -1:",
"- maze[h][w] = warp_n",
"- walk_stack.extend(walk(h, w))",
"- warp_set |= set(warp(h, w))",
"- warp_n += 1",
"- # print(*maze, sep='\\n')",
"- next_warp = set()",
"- for h, w in warp_set:",
"- if maze[h][w] == -1:",
"- maze[h][w] = warp_n",
"- walk_stack.extend(walk(h, w))",
"- next_warp |= set(warp(h, w))",
"- warp_set = next_warp",
"+ if h + dh < 0 or w + dw < 0 or h + dh >= H or w + dw >= W:",
"+ continue",
"+ if S[h + dh][w + dw] == \"#\":",
"+ continue",
"+ if dh == 0 and dw == 0:",
"+ continue",
"+ queue.append((h + dh, w + dw, warp_n + 1))"
]
| false | 0.040618 | 0.037015 | 1.097327 | [
"s639667204",
"s780938117"
]
|
u368796742 | p03999 | python | s653084927 | s585521031 | 27 | 19 | 3,060 | 3,060 | Accepted | Accepted | 29.63 | s = eval(input())
sum = 0
for bit in range(1<<(len(s)-1)):
f = s[0]
for i in range(len(s)-1):
if bit & (1<<i):
f += "+"
f += s[i+1]
sum += eval(f)
print(sum) | s = eval(input())
def dfs(i,f):
if i == len(s)-1:
return sum(list(map(int,f.split("+"))))
return dfs(i+1,f+s[i+1]) + dfs(i+1,f+"+"+s[i+1])
print((dfs(0,s[0]))) | 17 | 10 | 213 | 174 | s = eval(input())
sum = 0
for bit in range(1 << (len(s) - 1)):
f = s[0]
for i in range(len(s) - 1):
if bit & (1 << i):
f += "+"
f += s[i + 1]
sum += eval(f)
print(sum)
| s = eval(input())
def dfs(i, f):
if i == len(s) - 1:
return sum(list(map(int, f.split("+"))))
return dfs(i + 1, f + s[i + 1]) + dfs(i + 1, f + "+" + s[i + 1])
print((dfs(0, s[0])))
| false | 41.176471 | [
"-sum = 0",
"-for bit in range(1 << (len(s) - 1)):",
"- f = s[0]",
"- for i in range(len(s) - 1):",
"- if bit & (1 << i):",
"- f += \"+\"",
"- f += s[i + 1]",
"- sum += eval(f)",
"-print(sum)",
"+",
"+",
"+def dfs(i, f):",
"+ if i == len(s) - 1:",
"+ return sum(list(map(int, f.split(\"+\"))))",
"+ return dfs(i + 1, f + s[i + 1]) + dfs(i + 1, f + \"+\" + s[i + 1])",
"+",
"+",
"+print((dfs(0, s[0])))"
]
| false | 0.134541 | 0.07389 | 1.820829 | [
"s653084927",
"s585521031"
]
|
u175034939 | p02899 | python | s283651331 | s633036455 | 269 | 109 | 23,616 | 13,880 | Accepted | Accepted | 59.48 | n = int(eval(input()))
A = list(map(int, input().split()))
b = []
for i, a in enumerate(A):
b.append([a, i+1])
b.sort()
ans = []
for c in b:
ans.append(c[1])
print((*ans)) | n = int(eval(input()))
A = list(map(int, input().split()))
b = [0]*n
for i, a in enumerate(A):
b[a-1] = i+1
print((*b)) | 10 | 6 | 180 | 120 | n = int(eval(input()))
A = list(map(int, input().split()))
b = []
for i, a in enumerate(A):
b.append([a, i + 1])
b.sort()
ans = []
for c in b:
ans.append(c[1])
print((*ans))
| n = int(eval(input()))
A = list(map(int, input().split()))
b = [0] * n
for i, a in enumerate(A):
b[a - 1] = i + 1
print((*b))
| false | 40 | [
"-b = []",
"+b = [0] * n",
"- b.append([a, i + 1])",
"-b.sort()",
"-ans = []",
"-for c in b:",
"- ans.append(c[1])",
"-print((*ans))",
"+ b[a - 1] = i + 1",
"+print((*b))"
]
| false | 0.042698 | 0.039945 | 1.068912 | [
"s283651331",
"s633036455"
]
|
u353919145 | p03457 | python | s448372472 | s960328809 | 430 | 246 | 27,380 | 3,936 | Accepted | Accepted | 42.79 | # Q.C
N = int(eval(input()))
txy = [[0,0,0]]
for i in range(N):
txy.append(list(map(int,input().split(" "))))
def matchdist(x,y):
dt = abs(x[0]-y[0])
ds = abs(x[1]-y[1]) + abs(x[2]-y[2])
if ds%2 == dt%2 and ds<=dt:
return True
else:
return False
flag = False
for i in range(N):
if matchdist(txy[i],txy[i+1]):
continue
else:
print("No")
flag = True
break
if not flag:
print("Yes") | import sys
batch = 0
lines = 0
ans = []
for line in sys.stdin:
if line == None or line == '\n':
break
cur = line.split(" ")
if len(cur) == 1:
lines = int(cur[0])
batch = 0
continue
else:
batch += 1
if int(cur[0]) < int(cur[1]) + int(cur[2]):
ans.append(0)
elif (int(cur[0]) - int(cur[1]) - int(cur[2])) % 2 == 0:
ans.append(1)
else:
ans.append(0)
if batch == lines:
prod = 1
for n in ans:
prod *= n
if prod == 0:
print("No")
else:
print("Yes") | 24 | 31 | 478 | 716 | # Q.C
N = int(eval(input()))
txy = [[0, 0, 0]]
for i in range(N):
txy.append(list(map(int, input().split(" "))))
def matchdist(x, y):
dt = abs(x[0] - y[0])
ds = abs(x[1] - y[1]) + abs(x[2] - y[2])
if ds % 2 == dt % 2 and ds <= dt:
return True
else:
return False
flag = False
for i in range(N):
if matchdist(txy[i], txy[i + 1]):
continue
else:
print("No")
flag = True
break
if not flag:
print("Yes")
| import sys
batch = 0
lines = 0
ans = []
for line in sys.stdin:
if line == None or line == "\n":
break
cur = line.split(" ")
if len(cur) == 1:
lines = int(cur[0])
batch = 0
continue
else:
batch += 1
if int(cur[0]) < int(cur[1]) + int(cur[2]):
ans.append(0)
elif (int(cur[0]) - int(cur[1]) - int(cur[2])) % 2 == 0:
ans.append(1)
else:
ans.append(0)
if batch == lines:
prod = 1
for n in ans:
prod *= n
if prod == 0:
print("No")
else:
print("Yes")
| false | 22.580645 | [
"-# Q.C",
"-N = int(eval(input()))",
"-txy = [[0, 0, 0]]",
"-for i in range(N):",
"- txy.append(list(map(int, input().split(\" \"))))",
"+import sys",
"-",
"-def matchdist(x, y):",
"- dt = abs(x[0] - y[0])",
"- ds = abs(x[1] - y[1]) + abs(x[2] - y[2])",
"- if ds % 2 == dt % 2 and ds <= dt:",
"- return True",
"- else:",
"- return False",
"-",
"-",
"-flag = False",
"-for i in range(N):",
"- if matchdist(txy[i], txy[i + 1]):",
"+batch = 0",
"+lines = 0",
"+ans = []",
"+for line in sys.stdin:",
"+ if line == None or line == \"\\n\":",
"+ break",
"+ cur = line.split(\" \")",
"+ if len(cur) == 1:",
"+ lines = int(cur[0])",
"+ batch = 0",
"- print(\"No\")",
"- flag = True",
"- break",
"-if not flag:",
"- print(\"Yes\")",
"+ batch += 1",
"+ if int(cur[0]) < int(cur[1]) + int(cur[2]):",
"+ ans.append(0)",
"+ elif (int(cur[0]) - int(cur[1]) - int(cur[2])) % 2 == 0:",
"+ ans.append(1)",
"+ else:",
"+ ans.append(0)",
"+ if batch == lines:",
"+ prod = 1",
"+ for n in ans:",
"+ prod *= n",
"+ if prod == 0:",
"+ print(\"No\")",
"+ else:",
"+ print(\"Yes\")"
]
| false | 0.036502 | 0.042416 | 0.860561 | [
"s448372472",
"s960328809"
]
|
u581187895 | p03425 | python | s058036246 | s380607219 | 209 | 160 | 3,444 | 4,224 | Accepted | Accepted | 23.44 | from itertools import combinations
from collections import Counter
n = int(eval(input()))
S = Counter()
for i in range(n):
S[input()[0]] += 1 # Counter == dictionary
print((sum([S[a]*S[b]*S[c] for a, b, c in combinations("MARCH", 3)]))) | from collections import defaultdict
from itertools import combinations
N = int(eval(input()))
S = [input()[0] for _ in range(N)]
dic_S = defaultdict(int)
for s in S:
if s in "MARCH":
dic_S[s] += 1
ans = 0
for a, b, c in combinations(list(dic_S.values()), 3):
ans += a*b*c
print(ans)
| 9 | 16 | 245 | 304 | from itertools import combinations
from collections import Counter
n = int(eval(input()))
S = Counter()
for i in range(n):
S[input()[0]] += 1 # Counter == dictionary
print((sum([S[a] * S[b] * S[c] for a, b, c in combinations("MARCH", 3)])))
| from collections import defaultdict
from itertools import combinations
N = int(eval(input()))
S = [input()[0] for _ in range(N)]
dic_S = defaultdict(int)
for s in S:
if s in "MARCH":
dic_S[s] += 1
ans = 0
for a, b, c in combinations(list(dic_S.values()), 3):
ans += a * b * c
print(ans)
| false | 43.75 | [
"+from collections import defaultdict",
"-from collections import Counter",
"-n = int(eval(input()))",
"-S = Counter()",
"-for i in range(n):",
"- S[input()[0]] += 1 # Counter == dictionary",
"-print((sum([S[a] * S[b] * S[c] for a, b, c in combinations(\"MARCH\", 3)])))",
"+N = int(eval(input()))",
"+S = [input()[0] for _ in range(N)]",
"+dic_S = defaultdict(int)",
"+for s in S:",
"+ if s in \"MARCH\":",
"+ dic_S[s] += 1",
"+ans = 0",
"+for a, b, c in combinations(list(dic_S.values()), 3):",
"+ ans += a * b * c",
"+print(ans)"
]
| false | 0.043977 | 0.037129 | 1.184442 | [
"s058036246",
"s380607219"
]
|
u761529120 | p03213 | python | s370882664 | s206940766 | 173 | 69 | 38,352 | 65,856 | Accepted | Accepted | 60.12 | from collections import defaultdict
def main():
# 75 * 1
# 25 * 3
# 15 * 5
# 5 * 5 * 3
N = int(eval(input()))
d = defaultdict(int)
for n in range(1, N+1):
for i in range(2, int(n ** 0.5) + 1):
while n % i == 0:
d[i] += 1
n = n // i
if n != 1:
d[n] += 1
d2 = 0
d4 = 0
d14 = 0
d24 = 0
d74 = 0
for i in list(d.values()):
if i >= 2:
d2 += 1
if i >= 4:
d4 += 1
if i >= 14:
d14 += 1
if i >= 24:
d24 += 1
if i >= 74:
d74 += 1
ans = d74
ans += d24 * (d2 - 1)
ans += d14 * (d4 - 1)
ans += (d4 * (d4 - 1) * (d2 - 2)) // 2
print(ans)
if __name__ == "__main__":
main() | from collections import defaultdict
def prime_factor(n):
ass = []
for i in range(2,int(n**0.5)+1):
while n % i==0:
ass.append(i)
n = n//i
if n != 1:
ass.append(n)
return ass
def main():
N = int(eval(input()))
d = defaultdict(int)
for i in range(1,N+1):
for j in prime_factor(i):
d[j] += 1
# 1 * 75
# 3 * 25
# 5 * 15
# 3 * 5 * 5
e = defaultdict(int)
for i, j in list(d.items()):
if j >= 2:
e[2] += 1
if j >= 4:
e[4] += 1
if j >= 14:
e[14] += 1
if j >= 24:
e[24] += 1
if j >= 74:
e[74] += 1
ans = 0
ans += (e[2] - 1) * e[24]
ans += (e[4] - 1) * e[14]
ans += e[74]
ans += (e[2] - 2) * e[4] * (e[4] - 1) // 2
print(ans)
if __name__ == "__main__":
main() | 44 | 43 | 841 | 922 | from collections import defaultdict
def main():
# 75 * 1
# 25 * 3
# 15 * 5
# 5 * 5 * 3
N = int(eval(input()))
d = defaultdict(int)
for n in range(1, N + 1):
for i in range(2, int(n**0.5) + 1):
while n % i == 0:
d[i] += 1
n = n // i
if n != 1:
d[n] += 1
d2 = 0
d4 = 0
d14 = 0
d24 = 0
d74 = 0
for i in list(d.values()):
if i >= 2:
d2 += 1
if i >= 4:
d4 += 1
if i >= 14:
d14 += 1
if i >= 24:
d24 += 1
if i >= 74:
d74 += 1
ans = d74
ans += d24 * (d2 - 1)
ans += d14 * (d4 - 1)
ans += (d4 * (d4 - 1) * (d2 - 2)) // 2
print(ans)
if __name__ == "__main__":
main()
| from collections import defaultdict
def prime_factor(n):
ass = []
for i in range(2, int(n**0.5) + 1):
while n % i == 0:
ass.append(i)
n = n // i
if n != 1:
ass.append(n)
return ass
def main():
N = int(eval(input()))
d = defaultdict(int)
for i in range(1, N + 1):
for j in prime_factor(i):
d[j] += 1
# 1 * 75
# 3 * 25
# 5 * 15
# 3 * 5 * 5
e = defaultdict(int)
for i, j in list(d.items()):
if j >= 2:
e[2] += 1
if j >= 4:
e[4] += 1
if j >= 14:
e[14] += 1
if j >= 24:
e[24] += 1
if j >= 74:
e[74] += 1
ans = 0
ans += (e[2] - 1) * e[24]
ans += (e[4] - 1) * e[14]
ans += e[74]
ans += (e[2] - 2) * e[4] * (e[4] - 1) // 2
print(ans)
if __name__ == "__main__":
main()
| false | 2.272727 | [
"+def prime_factor(n):",
"+ ass = []",
"+ for i in range(2, int(n**0.5) + 1):",
"+ while n % i == 0:",
"+ ass.append(i)",
"+ n = n // i",
"+ if n != 1:",
"+ ass.append(n)",
"+ return ass",
"+",
"+",
"- # 75 * 1",
"- # 25 * 3",
"- # 15 * 5",
"- # 5 * 5 * 3",
"- for n in range(1, N + 1):",
"- for i in range(2, int(n**0.5) + 1):",
"- while n % i == 0:",
"- d[i] += 1",
"- n = n // i",
"- if n != 1:",
"- d[n] += 1",
"- d2 = 0",
"- d4 = 0",
"- d14 = 0",
"- d24 = 0",
"- d74 = 0",
"- for i in list(d.values()):",
"- if i >= 2:",
"- d2 += 1",
"- if i >= 4:",
"- d4 += 1",
"- if i >= 14:",
"- d14 += 1",
"- if i >= 24:",
"- d24 += 1",
"- if i >= 74:",
"- d74 += 1",
"- ans = d74",
"- ans += d24 * (d2 - 1)",
"- ans += d14 * (d4 - 1)",
"- ans += (d4 * (d4 - 1) * (d2 - 2)) // 2",
"+ for i in range(1, N + 1):",
"+ for j in prime_factor(i):",
"+ d[j] += 1",
"+ # 1 * 75",
"+ # 3 * 25",
"+ # 5 * 15",
"+ # 3 * 5 * 5",
"+ e = defaultdict(int)",
"+ for i, j in list(d.items()):",
"+ if j >= 2:",
"+ e[2] += 1",
"+ if j >= 4:",
"+ e[4] += 1",
"+ if j >= 14:",
"+ e[14] += 1",
"+ if j >= 24:",
"+ e[24] += 1",
"+ if j >= 74:",
"+ e[74] += 1",
"+ ans = 0",
"+ ans += (e[2] - 1) * e[24]",
"+ ans += (e[4] - 1) * e[14]",
"+ ans += e[74]",
"+ ans += (e[2] - 2) * e[4] * (e[4] - 1) // 2"
]
| false | 0.035852 | 0.035664 | 1.005277 | [
"s370882664",
"s206940766"
]
|
u644972721 | p02996 | python | s227083607 | s281033879 | 964 | 797 | 35,608 | 39,152 | Accepted | Accepted | 17.32 | n = int(eval(input()))
s = []
c = 0
for _ in range(n):
a, b = list(map(int, input().split()))
s.append([b, a])
s.sort()
for i in range(n):
c += s[i][1]
if c > s[i][0]:
c = -1
break
if c != -1:
print("Yes")
else:
print("No") | n = int(eval(input()))
x = [[0, 0]]
for _ in range(n):
a, b = list(map(int, input().split()))
x.append([b, a])
x.sort()
for i in range(1, n + 1):
x[i][1] += x[i - 1][1]
if x[i][0] < x[i][1]:
print("No")
exit()
print("Yes") | 16 | 12 | 266 | 253 | n = int(eval(input()))
s = []
c = 0
for _ in range(n):
a, b = list(map(int, input().split()))
s.append([b, a])
s.sort()
for i in range(n):
c += s[i][1]
if c > s[i][0]:
c = -1
break
if c != -1:
print("Yes")
else:
print("No")
| n = int(eval(input()))
x = [[0, 0]]
for _ in range(n):
a, b = list(map(int, input().split()))
x.append([b, a])
x.sort()
for i in range(1, n + 1):
x[i][1] += x[i - 1][1]
if x[i][0] < x[i][1]:
print("No")
exit()
print("Yes")
| false | 25 | [
"-s = []",
"-c = 0",
"+x = [[0, 0]]",
"- s.append([b, a])",
"-s.sort()",
"-for i in range(n):",
"- c += s[i][1]",
"- if c > s[i][0]:",
"- c = -1",
"- break",
"-if c != -1:",
"- print(\"Yes\")",
"-else:",
"- print(\"No\")",
"+ x.append([b, a])",
"+x.sort()",
"+for i in range(1, n + 1):",
"+ x[i][1] += x[i - 1][1]",
"+ if x[i][0] < x[i][1]:",
"+ print(\"No\")",
"+ exit()",
"+print(\"Yes\")"
]
| false | 0.074034 | 0.040213 | 1.841052 | [
"s227083607",
"s281033879"
]
|
u821624310 | p02410 | python | s781813582 | s270209939 | 30 | 20 | 7,992 | 8,000 | Accepted | Accepted | 33.33 | n, m = list(map(int, input().split()))
a = [[int(i) for i in input().split()] for j in range(n)]
b = [int(eval(input())) for i in range(m)]
c = [0 for i in range(n)]
for i in range(n):
for j in range(m):
c[i] += a[i][j] * b[j]
for i in range(n):
print((c[i]))
| n, m = list(map(int, input().split()))
A = [[int(e) for e in input().split()] for i in range(n)]
b = []
for i in range(m):
e = int(eval(input()))
b.append(e)
for i in range(n):
p = 0
for j in range(m):
p += A[i][j] * b[j]
print(p) | 11 | 11 | 277 | 256 | n, m = list(map(int, input().split()))
a = [[int(i) for i in input().split()] for j in range(n)]
b = [int(eval(input())) for i in range(m)]
c = [0 for i in range(n)]
for i in range(n):
for j in range(m):
c[i] += a[i][j] * b[j]
for i in range(n):
print((c[i]))
| n, m = list(map(int, input().split()))
A = [[int(e) for e in input().split()] for i in range(n)]
b = []
for i in range(m):
e = int(eval(input()))
b.append(e)
for i in range(n):
p = 0
for j in range(m):
p += A[i][j] * b[j]
print(p)
| false | 0 | [
"-a = [[int(i) for i in input().split()] for j in range(n)]",
"-b = [int(eval(input())) for i in range(m)]",
"-c = [0 for i in range(n)]",
"+A = [[int(e) for e in input().split()] for i in range(n)]",
"+b = []",
"+for i in range(m):",
"+ e = int(eval(input()))",
"+ b.append(e)",
"+ p = 0",
"- c[i] += a[i][j] * b[j]",
"-for i in range(n):",
"- print((c[i]))",
"+ p += A[i][j] * b[j]",
"+ print(p)"
]
| false | 0.052573 | 0.15271 | 0.34427 | [
"s781813582",
"s270209939"
]
|
u426534722 | p02269 | python | s340455088 | s867707013 | 1,280 | 930 | 31,424 | 31,636 | Accepted | Accepted | 27.34 | import sys
readline = sys.stdin.readline
SET = set()
for _ in range(int(readline())):
c, s = readline().split()
if c == "insert":
SET.add(s)
elif c == "find":
print(("yes" if s in SET else "no"))
| import sys
readline = sys.stdin.readline
SET = set()
eval(input())
for s in sys.stdin:
if s[0] == "i":
SET.add(s[7:])
elif s[0] == "f":
print(("yes" if s[5:] in SET else "no"))
| 10 | 10 | 232 | 203 | import sys
readline = sys.stdin.readline
SET = set()
for _ in range(int(readline())):
c, s = readline().split()
if c == "insert":
SET.add(s)
elif c == "find":
print(("yes" if s in SET else "no"))
| import sys
readline = sys.stdin.readline
SET = set()
eval(input())
for s in sys.stdin:
if s[0] == "i":
SET.add(s[7:])
elif s[0] == "f":
print(("yes" if s[5:] in SET else "no"))
| false | 0 | [
"-for _ in range(int(readline())):",
"- c, s = readline().split()",
"- if c == \"insert\":",
"- SET.add(s)",
"- elif c == \"find\":",
"- print((\"yes\" if s in SET else \"no\"))",
"+eval(input())",
"+for s in sys.stdin:",
"+ if s[0] == \"i\":",
"+ SET.add(s[7:])",
"+ elif s[0] == \"f\":",
"+ print((\"yes\" if s[5:] in SET else \"no\"))"
]
| false | 0.037143 | 0.043769 | 0.848604 | [
"s340455088",
"s867707013"
]
|
u670180528 | p02831 | python | s411106436 | s462685778 | 62 | 36 | 5,560 | 5,048 | Accepted | Accepted | 41.94 | from fractions import gcd
a,b=list(map(int,input().split()))
print((a*b//gcd(a,b))) | from fractions import*;a,b=list(map(int,input().split()));print((a*b//gcd(a,b))) | 3 | 1 | 77 | 72 | from fractions import gcd
a, b = list(map(int, input().split()))
print((a * b // gcd(a, b)))
| from fractions import *
a, b = list(map(int, input().split()))
print((a * b // gcd(a, b)))
| false | 66.666667 | [
"-from fractions import gcd",
"+from fractions import *"
]
| false | 0.087089 | 0.068955 | 1.262987 | [
"s411106436",
"s462685778"
]
|
u790710233 | p02936 | python | s580427851 | s162726590 | 1,888 | 1,258 | 237,360 | 63,848 | Accepted | Accepted | 33.37 | import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
n, q = list(map(int, input().split()))
edges = [[] for _ in range(n)]
for _ in range(n-1):
a, b = list([int(x)-1 for x in input().split()])
edges[a].append(b)
edges[b].append(a)
nodes = [0]*n
for _ in range(q):
p, x = list(map(int, input().split()))
nodes[p-1] += x
def dfs(v, parent, add):
nodes[v] += add
for v2 in edges[v]:
if v2 == parent:
continue
dfs(v2, v, nodes[v])
dfs(0, -1, 0)
print((*nodes)) | import sys
input = sys.stdin.readline
n, q = list(map(int, input().split()))
edges = [[] for _ in range(n)]
for _ in range(n-1):
a, b = list([int(x)-1 for x in input().split()])
edges[a].append(b)
edges[b].append(a)
values = [0]*n
for _ in range(q):
p, x = list(map(int, input().split()))
values[p-1] += x
stack = [0]
visited = [0]*n
while stack:
v = stack.pop()
if visited[v]:
continue
visited[v] = 1
for v2 in edges[v]:
if visited[v2]:
continue
values[v2] += values[v]
stack.append(v2)
print((*values))
| 25 | 27 | 545 | 604 | import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
n, q = list(map(int, input().split()))
edges = [[] for _ in range(n)]
for _ in range(n - 1):
a, b = list([int(x) - 1 for x in input().split()])
edges[a].append(b)
edges[b].append(a)
nodes = [0] * n
for _ in range(q):
p, x = list(map(int, input().split()))
nodes[p - 1] += x
def dfs(v, parent, add):
nodes[v] += add
for v2 in edges[v]:
if v2 == parent:
continue
dfs(v2, v, nodes[v])
dfs(0, -1, 0)
print((*nodes))
| import sys
input = sys.stdin.readline
n, q = list(map(int, input().split()))
edges = [[] for _ in range(n)]
for _ in range(n - 1):
a, b = list([int(x) - 1 for x in input().split()])
edges[a].append(b)
edges[b].append(a)
values = [0] * n
for _ in range(q):
p, x = list(map(int, input().split()))
values[p - 1] += x
stack = [0]
visited = [0] * n
while stack:
v = stack.pop()
if visited[v]:
continue
visited[v] = 1
for v2 in edges[v]:
if visited[v2]:
continue
values[v2] += values[v]
stack.append(v2)
print((*values))
| false | 7.407407 | [
"-sys.setrecursionlimit(10**7)",
"-nodes = [0] * n",
"+values = [0] * n",
"- nodes[p - 1] += x",
"-",
"-",
"-def dfs(v, parent, add):",
"- nodes[v] += add",
"+ values[p - 1] += x",
"+stack = [0]",
"+visited = [0] * n",
"+while stack:",
"+ v = stack.pop()",
"+ if visited[v]:",
"+ continue",
"+ visited[v] = 1",
"- if v2 == parent:",
"+ if visited[v2]:",
"- dfs(v2, v, nodes[v])",
"-",
"-",
"-dfs(0, -1, 0)",
"-print((*nodes))",
"+ values[v2] += values[v]",
"+ stack.append(v2)",
"+print((*values))"
]
| false | 0.037149 | 0.044772 | 0.829735 | [
"s580427851",
"s162726590"
]
|
u440566786 | p03038 | python | s881979622 | s975912551 | 541 | 478 | 72,448 | 73,256 | Accepted | Accepted | 11.65 | import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda :sys.stdin.readline().rstrip()
def resolve():
from bisect import bisect_left as bisect
n,m=list(map(int,input().split()))
A=list(map(int,input().split()))
A.sort()
BC=[tuple(map(int,input().split())) for _ in range(m)]
BC.sort(lambda x:-x[1])
now=0
ans=0
for b,c in BC:
i=bisect(A,c)
if(i<=now): continue
next=min(i,now+b)
ans+=c*(next-now)
now=next
print((ans+sum(A[now:])))
resolve() | import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda:sys.stdin.readline().rstrip()
def resolve():
n,m=list(map(int,input().split()))
A=list(map(int,input().split()))
A.sort()
BC=[list(map(int,input().split())) for _ in range(m)]
BC.sort(lambda x:x[1],reverse=1)
now=0
for b,c in BC:
while(b>0 and now<n and A[now]<c):
A[now]=c
now+=1
b-=1
print((sum(A)))
resolve() | 23 | 20 | 567 | 486 | import sys
sys.setrecursionlimit(2147483647)
INF = float("inf")
MOD = 10**9 + 7
input = lambda: sys.stdin.readline().rstrip()
def resolve():
from bisect import bisect_left as bisect
n, m = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
BC = [tuple(map(int, input().split())) for _ in range(m)]
BC.sort(lambda x: -x[1])
now = 0
ans = 0
for b, c in BC:
i = bisect(A, c)
if i <= now:
continue
next = min(i, now + b)
ans += c * (next - now)
now = next
print((ans + sum(A[now:])))
resolve()
| import sys
sys.setrecursionlimit(2147483647)
INF = float("inf")
MOD = 10**9 + 7
input = lambda: sys.stdin.readline().rstrip()
def resolve():
n, m = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
BC = [list(map(int, input().split())) for _ in range(m)]
BC.sort(lambda x: x[1], reverse=1)
now = 0
for b, c in BC:
while b > 0 and now < n and A[now] < c:
A[now] = c
now += 1
b -= 1
print((sum(A)))
resolve()
| false | 13.043478 | [
"- from bisect import bisect_left as bisect",
"-",
"- BC = [tuple(map(int, input().split())) for _ in range(m)]",
"- BC.sort(lambda x: -x[1])",
"+ BC = [list(map(int, input().split())) for _ in range(m)]",
"+ BC.sort(lambda x: x[1], reverse=1)",
"- ans = 0",
"- i = bisect(A, c)",
"- if i <= now:",
"- continue",
"- next = min(i, now + b)",
"- ans += c * (next - now)",
"- now = next",
"- print((ans + sum(A[now:])))",
"+ while b > 0 and now < n and A[now] < c:",
"+ A[now] = c",
"+ now += 1",
"+ b -= 1",
"+ print((sum(A)))"
]
| false | 0.037023 | 0.0367 | 1.008807 | [
"s881979622",
"s975912551"
]
|
u352394527 | p00521 | python | s128710836 | s666958997 | 2,400 | 1,080 | 30,368 | 30,368 | Accepted | Accepted | 55 | n, m = list(map(int,input().split()))
ss = [eval(input()) for i in range(n)]
a1, a2 = eval(input())
a3, a4 = eval(input())
dic = {"J":0, "O":1, "I":2}
n1, n2, n3, n4 = dic[a1], dic[a2], dic[a3], dic[a4]
fix = [[[0] * m for i in range(n)] for j in range(3)]
ans = 0
for x in range(n - 1):
for y in range(m - 1):
b1, b2, b3, b4 = ss[x][y], ss[x][y + 1], ss[x + 1][y], ss[x + 1][y + 1]
if a1 == b1 and a2 == b2 and a3 == b3 and a4 == b4:
ans += 1
for i in range(3):
if i != n1:
fix[i][x][y] -= 1
for i in range(3):
if i != n2:
fix[i][x][y + 1] -= 1
for i in range(3):
if i != n3:
fix[i][x + 1][y] -= 1
for i in range(3):
if i != n4:
fix[i][x + 1][y + 1] -= 1
elif not (a1 == b1) and a2 == b2 and a3 == b3 and a4 == b4:
fix[n1][x][y] += 1
elif a1 == b1 and not (a2 == b2) and a3 == b3 and a4 == b4:
fix[n2][x][y + 1] += 1
elif a1 == b1 and a2 == b2 and not (a3 == b3) and a4 == b4:
fix[n3][x + 1][y] += 1
elif a1 == b1 and a2 == b2 and a3 == b3 and not (a4 == b4):
fix[n4][x + 1][y + 1] += 1
rec = 0
for i in range(3):
for x in range(n):
for y in range(m):
if fix[i][x][y] > rec:
rec = fix[i][x][y]
print((ans + rec))
| def main():
n, m = list(map(int,input().split()))
ss = [eval(input()) for i in range(n)]
a1, a2 = eval(input())
a3, a4 = eval(input())
dic = {"J":0, "O":1, "I":2}
n1, n2, n3, n4 = dic[a1], dic[a2], dic[a3], dic[a4]
fix = [[[0] * m for i in range(n)] for j in range(3)]
ans = 0
for x in range(n - 1):
for y in range(m - 1):
b1, b2, b3, b4 = ss[x][y], ss[x][y + 1], ss[x + 1][y], ss[x + 1][y + 1]
if a1 == b1 and a2 == b2 and a3 == b3 and a4 == b4:
ans += 1
for i in range(3):
if i != n1:
fix[i][x][y] -= 1
if i != n2:
fix[i][x][y + 1] -= 1
if i != n3:
fix[i][x + 1][y] -= 1
if i != n4:
fix[i][x + 1][y + 1] -= 1
elif not (a1 == b1) and a2 == b2 and a3 == b3 and a4 == b4:
fix[n1][x][y] += 1
elif a1 == b1 and not (a2 == b2) and a3 == b3 and a4 == b4:
fix[n2][x][y + 1] += 1
elif a1 == b1 and a2 == b2 and not (a3 == b3) and a4 == b4:
fix[n3][x + 1][y] += 1
elif a1 == b1 and a2 == b2 and a3 == b3 and not (a4 == b4):
fix[n4][x + 1][y + 1] += 1
rec = 0
for i in range(3):
fixi = fix[i]
for x in range(n):
fixix = fixi[x]
for y in range(m):
if fixix[y] > rec:
rec = fixix[y]
if rec == 4:
break
if rec == 4:
break
if rec == 4:
break
print((ans + rec))
main()
| 45 | 55 | 1,310 | 1,490 | n, m = list(map(int, input().split()))
ss = [eval(input()) for i in range(n)]
a1, a2 = eval(input())
a3, a4 = eval(input())
dic = {"J": 0, "O": 1, "I": 2}
n1, n2, n3, n4 = dic[a1], dic[a2], dic[a3], dic[a4]
fix = [[[0] * m for i in range(n)] for j in range(3)]
ans = 0
for x in range(n - 1):
for y in range(m - 1):
b1, b2, b3, b4 = ss[x][y], ss[x][y + 1], ss[x + 1][y], ss[x + 1][y + 1]
if a1 == b1 and a2 == b2 and a3 == b3 and a4 == b4:
ans += 1
for i in range(3):
if i != n1:
fix[i][x][y] -= 1
for i in range(3):
if i != n2:
fix[i][x][y + 1] -= 1
for i in range(3):
if i != n3:
fix[i][x + 1][y] -= 1
for i in range(3):
if i != n4:
fix[i][x + 1][y + 1] -= 1
elif not (a1 == b1) and a2 == b2 and a3 == b3 and a4 == b4:
fix[n1][x][y] += 1
elif a1 == b1 and not (a2 == b2) and a3 == b3 and a4 == b4:
fix[n2][x][y + 1] += 1
elif a1 == b1 and a2 == b2 and not (a3 == b3) and a4 == b4:
fix[n3][x + 1][y] += 1
elif a1 == b1 and a2 == b2 and a3 == b3 and not (a4 == b4):
fix[n4][x + 1][y + 1] += 1
rec = 0
for i in range(3):
for x in range(n):
for y in range(m):
if fix[i][x][y] > rec:
rec = fix[i][x][y]
print((ans + rec))
| def main():
n, m = list(map(int, input().split()))
ss = [eval(input()) for i in range(n)]
a1, a2 = eval(input())
a3, a4 = eval(input())
dic = {"J": 0, "O": 1, "I": 2}
n1, n2, n3, n4 = dic[a1], dic[a2], dic[a3], dic[a4]
fix = [[[0] * m for i in range(n)] for j in range(3)]
ans = 0
for x in range(n - 1):
for y in range(m - 1):
b1, b2, b3, b4 = ss[x][y], ss[x][y + 1], ss[x + 1][y], ss[x + 1][y + 1]
if a1 == b1 and a2 == b2 and a3 == b3 and a4 == b4:
ans += 1
for i in range(3):
if i != n1:
fix[i][x][y] -= 1
if i != n2:
fix[i][x][y + 1] -= 1
if i != n3:
fix[i][x + 1][y] -= 1
if i != n4:
fix[i][x + 1][y + 1] -= 1
elif not (a1 == b1) and a2 == b2 and a3 == b3 and a4 == b4:
fix[n1][x][y] += 1
elif a1 == b1 and not (a2 == b2) and a3 == b3 and a4 == b4:
fix[n2][x][y + 1] += 1
elif a1 == b1 and a2 == b2 and not (a3 == b3) and a4 == b4:
fix[n3][x + 1][y] += 1
elif a1 == b1 and a2 == b2 and a3 == b3 and not (a4 == b4):
fix[n4][x + 1][y + 1] += 1
rec = 0
for i in range(3):
fixi = fix[i]
for x in range(n):
fixix = fixi[x]
for y in range(m):
if fixix[y] > rec:
rec = fixix[y]
if rec == 4:
break
if rec == 4:
break
if rec == 4:
break
print((ans + rec))
main()
| false | 18.181818 | [
"-n, m = list(map(int, input().split()))",
"-ss = [eval(input()) for i in range(n)]",
"-a1, a2 = eval(input())",
"-a3, a4 = eval(input())",
"-dic = {\"J\": 0, \"O\": 1, \"I\": 2}",
"-n1, n2, n3, n4 = dic[a1], dic[a2], dic[a3], dic[a4]",
"-fix = [[[0] * m for i in range(n)] for j in range(3)]",
"-ans = 0",
"-for x in range(n - 1):",
"- for y in range(m - 1):",
"- b1, b2, b3, b4 = ss[x][y], ss[x][y + 1], ss[x + 1][y], ss[x + 1][y + 1]",
"- if a1 == b1 and a2 == b2 and a3 == b3 and a4 == b4:",
"- ans += 1",
"- for i in range(3):",
"- if i != n1:",
"- fix[i][x][y] -= 1",
"- for i in range(3):",
"- if i != n2:",
"- fix[i][x][y + 1] -= 1",
"- for i in range(3):",
"- if i != n3:",
"- fix[i][x + 1][y] -= 1",
"- for i in range(3):",
"- if i != n4:",
"- fix[i][x + 1][y + 1] -= 1",
"- elif not (a1 == b1) and a2 == b2 and a3 == b3 and a4 == b4:",
"- fix[n1][x][y] += 1",
"- elif a1 == b1 and not (a2 == b2) and a3 == b3 and a4 == b4:",
"- fix[n2][x][y + 1] += 1",
"- elif a1 == b1 and a2 == b2 and not (a3 == b3) and a4 == b4:",
"- fix[n3][x + 1][y] += 1",
"- elif a1 == b1 and a2 == b2 and a3 == b3 and not (a4 == b4):",
"- fix[n4][x + 1][y + 1] += 1",
"-rec = 0",
"-for i in range(3):",
"- for x in range(n):",
"- for y in range(m):",
"- if fix[i][x][y] > rec:",
"- rec = fix[i][x][y]",
"-print((ans + rec))",
"+def main():",
"+ n, m = list(map(int, input().split()))",
"+ ss = [eval(input()) for i in range(n)]",
"+ a1, a2 = eval(input())",
"+ a3, a4 = eval(input())",
"+ dic = {\"J\": 0, \"O\": 1, \"I\": 2}",
"+ n1, n2, n3, n4 = dic[a1], dic[a2], dic[a3], dic[a4]",
"+ fix = [[[0] * m for i in range(n)] for j in range(3)]",
"+ ans = 0",
"+ for x in range(n - 1):",
"+ for y in range(m - 1):",
"+ b1, b2, b3, b4 = ss[x][y], ss[x][y + 1], ss[x + 1][y], ss[x + 1][y + 1]",
"+ if a1 == b1 and a2 == b2 and a3 == b3 and a4 == b4:",
"+ ans += 1",
"+ for i in range(3):",
"+ if i != n1:",
"+ fix[i][x][y] -= 1",
"+ if i != n2:",
"+ fix[i][x][y + 1] -= 1",
"+ if i != n3:",
"+ fix[i][x + 1][y] -= 1",
"+ if i != n4:",
"+ fix[i][x + 1][y + 1] -= 1",
"+ elif not (a1 == b1) and a2 == b2 and a3 == b3 and a4 == b4:",
"+ fix[n1][x][y] += 1",
"+ elif a1 == b1 and not (a2 == b2) and a3 == b3 and a4 == b4:",
"+ fix[n2][x][y + 1] += 1",
"+ elif a1 == b1 and a2 == b2 and not (a3 == b3) and a4 == b4:",
"+ fix[n3][x + 1][y] += 1",
"+ elif a1 == b1 and a2 == b2 and a3 == b3 and not (a4 == b4):",
"+ fix[n4][x + 1][y + 1] += 1",
"+ rec = 0",
"+ for i in range(3):",
"+ fixi = fix[i]",
"+ for x in range(n):",
"+ fixix = fixi[x]",
"+ for y in range(m):",
"+ if fixix[y] > rec:",
"+ rec = fixix[y]",
"+ if rec == 4:",
"+ break",
"+ if rec == 4:",
"+ break",
"+ if rec == 4:",
"+ break",
"+ print((ans + rec))",
"+",
"+",
"+main()"
]
| false | 0.04191 | 0.042132 | 0.99472 | [
"s128710836",
"s666958997"
]
|
u580697892 | p04035 | python | s745182104 | s487749821 | 267 | 149 | 68,708 | 14,304 | Accepted | Accepted | 44.19 | # coding: utf-8
N, L = map(int, input().split())
A = list(map(int, input().split()))
# Lより小さい組み合わせしか無い場合おわり
flag = False
for i in range(N-1):
if A[i] + A[i+1] >= L:
importance_i = i
flag = True
break
if not flag:
print("Impossible")
exit()
l, r = 0, N-1
print("Possible")
ans = []
while r - l > 1:
# print(l, r)
if l < importance_i:
ans.append(l+1)
l += 1
if r > importance_i+1:
ans.append(r)
r -= 1
# print("importance_i", importance_i)
ans.append(importance_i+1)
print(*ans, sep="\n")
| # coding: utf-8
N, L = list(map(int, input().split()))
A = list(map(int, input().split()))
flag = True
l = -1
for i in range(N-1):
if A[i] + A[i+1] >= L:
l = i+1
if l < 0:
print("Impossible")
exit()
knot = list(range(1, N))
print("Possible")
idx = 1
while idx < l:
print(idx)
idx += 1
idx = N-1
while idx > l:
print(idx)
idx -= 1
print(l) | 28 | 22 | 594 | 389 | # coding: utf-8
N, L = map(int, input().split())
A = list(map(int, input().split()))
# Lより小さい組み合わせしか無い場合おわり
flag = False
for i in range(N - 1):
if A[i] + A[i + 1] >= L:
importance_i = i
flag = True
break
if not flag:
print("Impossible")
exit()
l, r = 0, N - 1
print("Possible")
ans = []
while r - l > 1:
# print(l, r)
if l < importance_i:
ans.append(l + 1)
l += 1
if r > importance_i + 1:
ans.append(r)
r -= 1
# print("importance_i", importance_i)
ans.append(importance_i + 1)
print(*ans, sep="\n")
| # coding: utf-8
N, L = list(map(int, input().split()))
A = list(map(int, input().split()))
flag = True
l = -1
for i in range(N - 1):
if A[i] + A[i + 1] >= L:
l = i + 1
if l < 0:
print("Impossible")
exit()
knot = list(range(1, N))
print("Possible")
idx = 1
while idx < l:
print(idx)
idx += 1
idx = N - 1
while idx > l:
print(idx)
idx -= 1
print(l)
| false | 21.428571 | [
"-N, L = map(int, input().split())",
"+N, L = list(map(int, input().split()))",
"-# Lより小さい組み合わせしか無い場合おわり",
"-flag = False",
"+flag = True",
"+l = -1",
"- importance_i = i",
"- flag = True",
"- break",
"-if not flag:",
"+ l = i + 1",
"+if l < 0:",
"-l, r = 0, N - 1",
"+knot = list(range(1, N))",
"-ans = []",
"-while r - l > 1:",
"- # print(l, r)",
"- if l < importance_i:",
"- ans.append(l + 1)",
"- l += 1",
"- if r > importance_i + 1:",
"- ans.append(r)",
"- r -= 1",
"-# print(\"importance_i\", importance_i)",
"-ans.append(importance_i + 1)",
"-print(*ans, sep=\"\\n\")",
"+idx = 1",
"+while idx < l:",
"+ print(idx)",
"+ idx += 1",
"+idx = N - 1",
"+while idx > l:",
"+ print(idx)",
"+ idx -= 1",
"+print(l)"
]
| false | 0.046875 | 0.037682 | 1.243954 | [
"s745182104",
"s487749821"
]
|
u562016607 | p03557 | python | s621234078 | s092641244 | 333 | 300 | 23,328 | 23,244 | Accepted | Accepted | 9.91 | from bisect import bisect_left,bisect_right;N=int(eval(input()));A,B,C=[list(map(int,input().split())) for _ in "ABC"];A.sort();C.sort();print((sum([bisect_left(A,i)*(N-bisect_right(C,i)) for i in B]))) | import bisect;N=int(eval(input()));A,B,C=[sorted(list(map(int,input().split()))) for _ in "ABC"];print((sum([bisect.bisect_left(A,i)*(N-bisect.bisect_right(C,i)) for i in B])))
| 1 | 1 | 194 | 169 | from bisect import bisect_left, bisect_right
N = int(eval(input()))
A, B, C = [list(map(int, input().split())) for _ in "ABC"]
A.sort()
C.sort()
print((sum([bisect_left(A, i) * (N - bisect_right(C, i)) for i in B])))
| import bisect
N = int(eval(input()))
A, B, C = [sorted(list(map(int, input().split()))) for _ in "ABC"]
print((sum([bisect.bisect_left(A, i) * (N - bisect.bisect_right(C, i)) for i in B])))
| false | 0 | [
"-from bisect import bisect_left, bisect_right",
"+import bisect",
"-A, B, C = [list(map(int, input().split())) for _ in \"ABC\"]",
"-A.sort()",
"-C.sort()",
"-print((sum([bisect_left(A, i) * (N - bisect_right(C, i)) for i in B])))",
"+A, B, C = [sorted(list(map(int, input().split()))) for _ in \"ABC\"]",
"+print((sum([bisect.bisect_left(A, i) * (N - bisect.bisect_right(C, i)) for i in B])))"
]
| false | 0.133424 | 0.084309 | 1.582562 | [
"s621234078",
"s092641244"
]
|
u835482198 | p04005 | python | s265010519 | s187068317 | 22 | 17 | 3,064 | 2,940 | Accepted | Accepted | 22.73 | #!/usr/bin/env python
# -*- coding:utf-8 -*-
a = sorted(map(int, input().split()))
tmp = (a[2] // 2)
# print(a[0] * a[1] * tmp)
# print(a[0] * a[1] * (a[2] - tmp))
print(((a[0] * a[1]) * (a[2] - 2 * tmp)))
| A = list(sorted(map(int, input().split())))
tmp = A[-1] // 2
print((A[0] * A[1] * (A[-1] - 2 * tmp))) | 8 | 3 | 213 | 101 | #!/usr/bin/env python
# -*- coding:utf-8 -*-
a = sorted(map(int, input().split()))
tmp = a[2] // 2
# print(a[0] * a[1] * tmp)
# print(a[0] * a[1] * (a[2] - tmp))
print(((a[0] * a[1]) * (a[2] - 2 * tmp)))
| A = list(sorted(map(int, input().split())))
tmp = A[-1] // 2
print((A[0] * A[1] * (A[-1] - 2 * tmp)))
| false | 62.5 | [
"-#!/usr/bin/env python",
"-# -*- coding:utf-8 -*-",
"-a = sorted(map(int, input().split()))",
"-tmp = a[2] // 2",
"-# print(a[0] * a[1] * tmp)",
"-# print(a[0] * a[1] * (a[2] - tmp))",
"-print(((a[0] * a[1]) * (a[2] - 2 * tmp)))",
"+A = list(sorted(map(int, input().split())))",
"+tmp = A[-1] // 2",
"+print((A[0] * A[1] * (A[-1] - 2 * tmp)))"
]
| false | 0.032859 | 0.03246 | 1.01229 | [
"s265010519",
"s187068317"
]
|
u801049006 | p03295 | python | s295340668 | s883962098 | 436 | 335 | 29,852 | 28,564 | Accepted | Accepted | 23.17 | n, m = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(m)]
ab = sorted(ab, key = lambda x : x[1])
ans = 0
end = 0
for i in range(m):
if ab[i][0] >= end:
end = ab[i][1]
ans += 1
print(ans) | n, m = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(m)]
ab.sort(key=lambda x: x[1])
ans = m
for i in range(1, m):
if ab[i][0] < ab[i-1][1]:
ab[i][1] = ab[i-1][1]
ans -= 1
print(ans)
| 12 | 11 | 251 | 248 | n, m = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(m)]
ab = sorted(ab, key=lambda x: x[1])
ans = 0
end = 0
for i in range(m):
if ab[i][0] >= end:
end = ab[i][1]
ans += 1
print(ans)
| n, m = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(m)]
ab.sort(key=lambda x: x[1])
ans = m
for i in range(1, m):
if ab[i][0] < ab[i - 1][1]:
ab[i][1] = ab[i - 1][1]
ans -= 1
print(ans)
| false | 8.333333 | [
"-ab = sorted(ab, key=lambda x: x[1])",
"-ans = 0",
"-end = 0",
"-for i in range(m):",
"- if ab[i][0] >= end:",
"- end = ab[i][1]",
"- ans += 1",
"+ab.sort(key=lambda x: x[1])",
"+ans = m",
"+for i in range(1, m):",
"+ if ab[i][0] < ab[i - 1][1]:",
"+ ab[i][1] = ab[i - 1][1]",
"+ ans -= 1"
]
| false | 0.035252 | 0.037041 | 0.951695 | [
"s295340668",
"s883962098"
]
|
u366959492 | p03130 | python | s292194184 | s614942518 | 196 | 168 | 38,384 | 38,384 | Accepted | Accepted | 14.29 | g=[0]*5
for _ in range(3):
a,b=list(map(int,input().split()))
g[a]+=1
g[b]+=1
if g.count(1)==2:
print("YES")
else:
print("NO")
| g=[0]*5
import sys
input=sys.stdin.readline
for _ in range(3):
a,b=list(map(int,input().split()))
g[a]+=1
g[b]+=1
if g.count(1)==2:
print("YES")
else:
print("NO")
| 9 | 11 | 149 | 187 | g = [0] * 5
for _ in range(3):
a, b = list(map(int, input().split()))
g[a] += 1
g[b] += 1
if g.count(1) == 2:
print("YES")
else:
print("NO")
| g = [0] * 5
import sys
input = sys.stdin.readline
for _ in range(3):
a, b = list(map(int, input().split()))
g[a] += 1
g[b] += 1
if g.count(1) == 2:
print("YES")
else:
print("NO")
| false | 18.181818 | [
"+import sys",
"+",
"+input = sys.stdin.readline"
]
| false | 0.077169 | 0.076902 | 1.003478 | [
"s292194184",
"s614942518"
]
|
u802963389 | p03212 | python | s459500916 | s327784704 | 94 | 86 | 3,060 | 4,724 | Accepted | Accepted | 8.51 | N = int(eval(input()))
def dfs(s):
if int(s) > N:
return 0
ret = 1 if all(s.count(c) for c in "357") else 0
for c in "357":
ret += dfs(s+c)
return ret
print((dfs("0"))) | from collections import deque
n = int(eval(input()))
li = [3, 5, 7]
def dfs():
stack = deque()
for i in li:
stack.append(i)
while stack:
q = stack.popleft()
if all(str(l) in str(q) for l in li):
ans.append(q)
for k in li:
if q * 10 + k <= n:
stack.append(q * 10 + k)
ans = []
dfs()
print((len(ans))) | 12 | 20 | 208 | 365 | N = int(eval(input()))
def dfs(s):
if int(s) > N:
return 0
ret = 1 if all(s.count(c) for c in "357") else 0
for c in "357":
ret += dfs(s + c)
return ret
print((dfs("0")))
| from collections import deque
n = int(eval(input()))
li = [3, 5, 7]
def dfs():
stack = deque()
for i in li:
stack.append(i)
while stack:
q = stack.popleft()
if all(str(l) in str(q) for l in li):
ans.append(q)
for k in li:
if q * 10 + k <= n:
stack.append(q * 10 + k)
ans = []
dfs()
print((len(ans)))
| false | 40 | [
"-N = int(eval(input()))",
"+from collections import deque",
"+",
"+n = int(eval(input()))",
"+li = [3, 5, 7]",
"-def dfs(s):",
"- if int(s) > N:",
"- return 0",
"- ret = 1 if all(s.count(c) for c in \"357\") else 0",
"- for c in \"357\":",
"- ret += dfs(s + c)",
"- return ret",
"+def dfs():",
"+ stack = deque()",
"+ for i in li:",
"+ stack.append(i)",
"+ while stack:",
"+ q = stack.popleft()",
"+ if all(str(l) in str(q) for l in li):",
"+ ans.append(q)",
"+ for k in li:",
"+ if q * 10 + k <= n:",
"+ stack.append(q * 10 + k)",
"-print((dfs(\"0\")))",
"+ans = []",
"+dfs()",
"+print((len(ans)))"
]
| false | 0.069683 | 0.058508 | 1.191002 | [
"s459500916",
"s327784704"
]
|
u254871849 | p03450 | python | s305768099 | s254502748 | 1,333 | 1,108 | 99,192 | 101,084 | Accepted | Accepted | 16.88 | import sys
n, m = list(map(int, sys.stdin.readline().split()))
graph = [[] for _ in range(n+1)]
for l, r, d in zip(*[list(map(int, sys.stdin.read().split()))] * 3):
graph[l].append((r, d))
graph[r].append((l, -d))
root = list(range(n+1))
height = [0] * (n + 1)
def find_root(v):
u = root[v]
if u == v:
return u
w = find_root(u)
root[v] = w
return w
def merge(v, u):
rv = find_root(v)
ru = find_root(u)
if rv != ru:
if height[v] >= height[u]:
root[ru] = rv
height[v] = max(height[v], height[v] + 1)
else:
root[rv] = ru
def main():
for v in range(1, n+1):
for u, d in graph[v]:
merge(v, u)
for v in range(1, n+1):
find_root(v)
dist = [None] * (n + 1)
for v in set(root[1:]):
dist[v] = 0
stack = [v]
while stack:
x = stack.pop()
for y, d in graph[x]:
if dist[y] is None:
dist[y] = dist[x] + d
stack.append(y)
elif dist[y] != dist[x] + d:
return 'No'
return 'Yes'
if __name__ == '__main__':
ans = main()
print(ans) | import sys
n, m = list(map(int, sys.stdin.readline().split()))
root = list(range(n+1))
height = [0] * (n + 1)
def find_root(v):
u = root[v]
if u == v:
return u
w = find_root(u)
root[v] = w
return w
def merge(v, u):
rv = find_root(v)
ru = find_root(u)
if rv != ru:
if height[v] >= height[u]:
root[ru] = rv
height[v] = max(height[v], height[v] + 1)
else:
root[rv] = ru
graph = [[] for _ in range(n+1)]
for l, r, d in zip(*[list(map(int, sys.stdin.read().split()))] * 3):
graph[l].append((r, d))
graph[r].append((l, -d))
merge(l, r)
for v in range(1, n+1):
find_root(v)
def main():
dist = [None] * (n + 1)
for v in set(root[1:]):
dist[v] = 0
stack = [v]
while stack:
x = stack.pop()
for y, d in graph[x]:
if dist[y] is None:
dist[y] = dist[x] + d
stack.append(y)
elif dist[y] != dist[x] + d:
return 'No'
return 'Yes'
if __name__ == '__main__':
ans = main()
print(ans) | 54 | 52 | 1,269 | 1,189 | import sys
n, m = list(map(int, sys.stdin.readline().split()))
graph = [[] for _ in range(n + 1)]
for l, r, d in zip(*[list(map(int, sys.stdin.read().split()))] * 3):
graph[l].append((r, d))
graph[r].append((l, -d))
root = list(range(n + 1))
height = [0] * (n + 1)
def find_root(v):
u = root[v]
if u == v:
return u
w = find_root(u)
root[v] = w
return w
def merge(v, u):
rv = find_root(v)
ru = find_root(u)
if rv != ru:
if height[v] >= height[u]:
root[ru] = rv
height[v] = max(height[v], height[v] + 1)
else:
root[rv] = ru
def main():
for v in range(1, n + 1):
for u, d in graph[v]:
merge(v, u)
for v in range(1, n + 1):
find_root(v)
dist = [None] * (n + 1)
for v in set(root[1:]):
dist[v] = 0
stack = [v]
while stack:
x = stack.pop()
for y, d in graph[x]:
if dist[y] is None:
dist[y] = dist[x] + d
stack.append(y)
elif dist[y] != dist[x] + d:
return "No"
return "Yes"
if __name__ == "__main__":
ans = main()
print(ans)
| import sys
n, m = list(map(int, sys.stdin.readline().split()))
root = list(range(n + 1))
height = [0] * (n + 1)
def find_root(v):
u = root[v]
if u == v:
return u
w = find_root(u)
root[v] = w
return w
def merge(v, u):
rv = find_root(v)
ru = find_root(u)
if rv != ru:
if height[v] >= height[u]:
root[ru] = rv
height[v] = max(height[v], height[v] + 1)
else:
root[rv] = ru
graph = [[] for _ in range(n + 1)]
for l, r, d in zip(*[list(map(int, sys.stdin.read().split()))] * 3):
graph[l].append((r, d))
graph[r].append((l, -d))
merge(l, r)
for v in range(1, n + 1):
find_root(v)
def main():
dist = [None] * (n + 1)
for v in set(root[1:]):
dist[v] = 0
stack = [v]
while stack:
x = stack.pop()
for y, d in graph[x]:
if dist[y] is None:
dist[y] = dist[x] + d
stack.append(y)
elif dist[y] != dist[x] + d:
return "No"
return "Yes"
if __name__ == "__main__":
ans = main()
print(ans)
| false | 3.703704 | [
"-graph = [[] for _ in range(n + 1)]",
"-for l, r, d in zip(*[list(map(int, sys.stdin.read().split()))] * 3):",
"- graph[l].append((r, d))",
"- graph[r].append((l, -d))",
"+graph = [[] for _ in range(n + 1)]",
"+for l, r, d in zip(*[list(map(int, sys.stdin.read().split()))] * 3):",
"+ graph[l].append((r, d))",
"+ graph[r].append((l, -d))",
"+ merge(l, r)",
"+for v in range(1, n + 1):",
"+ find_root(v)",
"+",
"+",
"- for v in range(1, n + 1):",
"- for u, d in graph[v]:",
"- merge(v, u)",
"- for v in range(1, n + 1):",
"- find_root(v)"
]
| false | 0.041359 | 0.039233 | 1.054193 | [
"s305768099",
"s254502748"
]
|
u131464432 | p03131 | python | s558985143 | s388665204 | 31 | 27 | 9,128 | 9,180 | Accepted | Accepted | 12.9 | K,A,B = list(map(int,input().split()))
if B-A <= 2:
print((1+K))
exit()
time = K - A + 1
print((A + time//2*(B-A) + time%2)) | K,A,B = list(map(int,input().split()))
if A + 2 > B:
print((K + 1))
exit()
start = A - 1
K -= start
ans = K//2 * (B-A) + K%2 + start + 1
print(ans) | 6 | 10 | 127 | 158 | K, A, B = list(map(int, input().split()))
if B - A <= 2:
print((1 + K))
exit()
time = K - A + 1
print((A + time // 2 * (B - A) + time % 2))
| K, A, B = list(map(int, input().split()))
if A + 2 > B:
print((K + 1))
exit()
start = A - 1
K -= start
ans = K // 2 * (B - A) + K % 2 + start + 1
print(ans)
| false | 40 | [
"-if B - A <= 2:",
"- print((1 + K))",
"+if A + 2 > B:",
"+ print((K + 1))",
"-time = K - A + 1",
"-print((A + time // 2 * (B - A) + time % 2))",
"+start = A - 1",
"+K -= start",
"+ans = K // 2 * (B - A) + K % 2 + start + 1",
"+print(ans)"
]
| false | 0.09807 | 0.046426 | 2.112394 | [
"s558985143",
"s388665204"
]
|
u280978334 | p03240 | python | s786184597 | s076545263 | 31 | 28 | 3,064 | 3,064 | Accepted | Accepted | 9.68 | n = int(input())
XYH = []
for _ in range(n):
x,y,h = map(int,input().split())
if h != 0:
XYH.append([x,y,h])
flag = False
ans = XYH[0]
for i in range(101):
for j in range(101):
tempH = abs(XYH[0][0] - i) + abs(XYH[0][1] - j) + XYH[0][2]
for x,y,h in XYH[1:]:
if abs(x - i) + abs(y - j) + h != tempH:
flag = False
break
else:
flag = True
if flag:
ans = [i,j,tempH]
break
if flag:
break
print(*ans,sep = " ")
| from sys import setrecursionlimit
from operator import itemgetter
def main():
N = int(eval(input()))
XYH = [list(map(int,input().split())) for _ in range(N)]
XYH.sort(key = itemgetter(2),reverse = True)
ansx = -1
ansy = -1
for cx in range(0,101):
for cy in range(0,101):
H = -1
flag = True
for x,y,h in XYH:
if H >= 0:
if h != max(H - abs(x - cx) - abs(y - cy),0):
flag = False
break
elif h > 0:
H = h + abs(x - cx) + abs(y - cy)
if flag:
ansx = cx
ansy = cy
print((ansx,ansy,H))
return
return
if __name__ == "__main__":
main() | 26 | 29 | 586 | 825 | n = int(input())
XYH = []
for _ in range(n):
x, y, h = map(int, input().split())
if h != 0:
XYH.append([x, y, h])
flag = False
ans = XYH[0]
for i in range(101):
for j in range(101):
tempH = abs(XYH[0][0] - i) + abs(XYH[0][1] - j) + XYH[0][2]
for x, y, h in XYH[1:]:
if abs(x - i) + abs(y - j) + h != tempH:
flag = False
break
else:
flag = True
if flag:
ans = [i, j, tempH]
break
if flag:
break
print(*ans, sep=" ")
| from sys import setrecursionlimit
from operator import itemgetter
def main():
N = int(eval(input()))
XYH = [list(map(int, input().split())) for _ in range(N)]
XYH.sort(key=itemgetter(2), reverse=True)
ansx = -1
ansy = -1
for cx in range(0, 101):
for cy in range(0, 101):
H = -1
flag = True
for x, y, h in XYH:
if H >= 0:
if h != max(H - abs(x - cx) - abs(y - cy), 0):
flag = False
break
elif h > 0:
H = h + abs(x - cx) + abs(y - cy)
if flag:
ansx = cx
ansy = cy
print((ansx, ansy, H))
return
return
if __name__ == "__main__":
main()
| false | 10.344828 | [
"-n = int(input())",
"-XYH = []",
"-for _ in range(n):",
"- x, y, h = map(int, input().split())",
"- if h != 0:",
"- XYH.append([x, y, h])",
"-flag = False",
"-ans = XYH[0]",
"-for i in range(101):",
"- for j in range(101):",
"- tempH = abs(XYH[0][0] - i) + abs(XYH[0][1] - j) + XYH[0][2]",
"- for x, y, h in XYH[1:]:",
"- if abs(x - i) + abs(y - j) + h != tempH:",
"- flag = False",
"- break",
"- else:",
"- flag = True",
"- if flag:",
"- ans = [i, j, tempH]",
"- break",
"- if flag:",
"- break",
"-print(*ans, sep=\" \")",
"+from sys import setrecursionlimit",
"+from operator import itemgetter",
"+",
"+",
"+def main():",
"+ N = int(eval(input()))",
"+ XYH = [list(map(int, input().split())) for _ in range(N)]",
"+ XYH.sort(key=itemgetter(2), reverse=True)",
"+ ansx = -1",
"+ ansy = -1",
"+ for cx in range(0, 101):",
"+ for cy in range(0, 101):",
"+ H = -1",
"+ flag = True",
"+ for x, y, h in XYH:",
"+ if H >= 0:",
"+ if h != max(H - abs(x - cx) - abs(y - cy), 0):",
"+ flag = False",
"+ break",
"+ elif h > 0:",
"+ H = h + abs(x - cx) + abs(y - cy)",
"+ if flag:",
"+ ansx = cx",
"+ ansy = cy",
"+ print((ansx, ansy, H))",
"+ return",
"+ return",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
]
| false | 0.051784 | 0.052555 | 0.98533 | [
"s786184597",
"s076545263"
]
|
u826188728 | p02901 | python | s073970331 | s749626966 | 1,191 | 995 | 3,188 | 3,188 | Accepted | Accepted | 16.46 | n, m = list(map(int, input().split()))
p = 1 << n
dp = [float('inf')] * p
dp[0] = 0
for i in range(m):
a, b = list(map(int, input().split()))
c = sum([1 << j - 1 for j in list(map(int, input().split()))])
for k in range(p):
if dp[k|c] > dp[k] + a:
dp[k|c] = dp[k] + a
if dp[-1] == float('inf'):
print((-1))
else:
print((dp[-1])) | n, m = list(map(int, input().split()))
p = 2 ** n
inf = 10 ** 9
dp = [inf] * p
dp[0] = 0
for i in range(m):
a, b = list(map(int, input().split()))
c = sum([2 ** (j - 1) for j in list(map(int, input().split()))])
for k in range(p):
if dp[k|c] > dp[k] + a:
dp[k|c] = dp[k] + a
if dp[-1] == inf:
print((-1))
else:
print((dp[-1])) | 15 | 16 | 353 | 352 | n, m = list(map(int, input().split()))
p = 1 << n
dp = [float("inf")] * p
dp[0] = 0
for i in range(m):
a, b = list(map(int, input().split()))
c = sum([1 << j - 1 for j in list(map(int, input().split()))])
for k in range(p):
if dp[k | c] > dp[k] + a:
dp[k | c] = dp[k] + a
if dp[-1] == float("inf"):
print((-1))
else:
print((dp[-1]))
| n, m = list(map(int, input().split()))
p = 2**n
inf = 10**9
dp = [inf] * p
dp[0] = 0
for i in range(m):
a, b = list(map(int, input().split()))
c = sum([2 ** (j - 1) for j in list(map(int, input().split()))])
for k in range(p):
if dp[k | c] > dp[k] + a:
dp[k | c] = dp[k] + a
if dp[-1] == inf:
print((-1))
else:
print((dp[-1]))
| false | 6.25 | [
"-p = 1 << n",
"-dp = [float(\"inf\")] * p",
"+p = 2**n",
"+inf = 10**9",
"+dp = [inf] * p",
"- c = sum([1 << j - 1 for j in list(map(int, input().split()))])",
"+ c = sum([2 ** (j - 1) for j in list(map(int, input().split()))])",
"-if dp[-1] == float(\"inf\"):",
"+if dp[-1] == inf:"
]
| false | 0.047168 | 0.066084 | 0.713755 | [
"s073970331",
"s749626966"
]
|
u231685196 | p03045 | python | s469066539 | s683677804 | 1,834 | 1,454 | 141,784 | 122,016 | Accepted | Accepted | 20.72 | class UnionFind():
'''UnionFind木'''
def __init__(self, n):
self.data = [-1] * n
def unite(self, x, y):
'''x と y を結合'''
x = self.find(x)
y = self.find(y)
if x == y:
return
elif self.data[x] < self.data[y]:
x, y = y, x # swap
self.data[x] += self.data[y]
self.data[y] = x
def find(self, x):
'''ノード x の親を返す'''
if self.data[x] < 0:
return x
self.data[x] = self.find(self.data[x])
return self.data[x]
def same(self, x, y):
'''x と y が同じグループに属するか判定'''
return self.find(x) == self.find(y)
def size(self, x):
'''x を含むグループのノード数を返す'''
return self.data[self.find(x)]
def indep(self):
dep = 0
for i in range(len(self.data)):
if self.data[i] < 0:
dep += 1
return dep
n,m = list(map(int,input().split()))
uf = UnionFind(n+1)
for i in range(m):
x,y,z = list(map(int,input().split()))
uf.unite(x,y)
print((uf.indep()-1))
| class uf_tree():
def __init__(self,n):
self.n = n
self.par = [i for i in range(n)]
def indep(self):
dep =0
for i in range(self.n):
if i == self.par[i]:
dep += 1
return dep
def unite(self,child,mas):
if self.root(child) == self.root(mas):
return
else:
self.par[self.root(child)] = self.root(mas)
def root(self,i):
if self.par[i] == i:
return i
else:
self.par[i] = self.root(self.par[i])
return self.par[i]
def same(self,x,y):
if self.root(x) == self.root(y):
return True
else:
return False
n,m = list(map(int,input().split()))
uf = uf_tree(n+1)
for i in range(m):
x,y,z = list(map(int,input().split()))
uf.unite(x,y)
print((uf.indep()-1))
| 46 | 42 | 1,096 | 903 | class UnionFind:
"""UnionFind木"""
def __init__(self, n):
self.data = [-1] * n
def unite(self, x, y):
"""x と y を結合"""
x = self.find(x)
y = self.find(y)
if x == y:
return
elif self.data[x] < self.data[y]:
x, y = y, x # swap
self.data[x] += self.data[y]
self.data[y] = x
def find(self, x):
"""ノード x の親を返す"""
if self.data[x] < 0:
return x
self.data[x] = self.find(self.data[x])
return self.data[x]
def same(self, x, y):
"""x と y が同じグループに属するか判定"""
return self.find(x) == self.find(y)
def size(self, x):
"""x を含むグループのノード数を返す"""
return self.data[self.find(x)]
def indep(self):
dep = 0
for i in range(len(self.data)):
if self.data[i] < 0:
dep += 1
return dep
n, m = list(map(int, input().split()))
uf = UnionFind(n + 1)
for i in range(m):
x, y, z = list(map(int, input().split()))
uf.unite(x, y)
print((uf.indep() - 1))
| class uf_tree:
def __init__(self, n):
self.n = n
self.par = [i for i in range(n)]
def indep(self):
dep = 0
for i in range(self.n):
if i == self.par[i]:
dep += 1
return dep
def unite(self, child, mas):
if self.root(child) == self.root(mas):
return
else:
self.par[self.root(child)] = self.root(mas)
def root(self, i):
if self.par[i] == i:
return i
else:
self.par[i] = self.root(self.par[i])
return self.par[i]
def same(self, x, y):
if self.root(x) == self.root(y):
return True
else:
return False
n, m = list(map(int, input().split()))
uf = uf_tree(n + 1)
for i in range(m):
x, y, z = list(map(int, input().split()))
uf.unite(x, y)
print((uf.indep() - 1))
| false | 8.695652 | [
"-class UnionFind:",
"- \"\"\"UnionFind木\"\"\"",
"-",
"+class uf_tree:",
"- self.data = [-1] * n",
"-",
"- def unite(self, x, y):",
"- \"\"\"x と y を結合\"\"\"",
"- x = self.find(x)",
"- y = self.find(y)",
"- if x == y:",
"- return",
"- elif self.data[x] < self.data[y]:",
"- x, y = y, x # swap",
"- self.data[x] += self.data[y]",
"- self.data[y] = x",
"-",
"- def find(self, x):",
"- \"\"\"ノード x の親を返す\"\"\"",
"- if self.data[x] < 0:",
"- return x",
"- self.data[x] = self.find(self.data[x])",
"- return self.data[x]",
"-",
"- def same(self, x, y):",
"- \"\"\"x と y が同じグループに属するか判定\"\"\"",
"- return self.find(x) == self.find(y)",
"-",
"- def size(self, x):",
"- \"\"\"x を含むグループのノード数を返す\"\"\"",
"- return self.data[self.find(x)]",
"+ self.n = n",
"+ self.par = [i for i in range(n)]",
"- for i in range(len(self.data)):",
"- if self.data[i] < 0:",
"+ for i in range(self.n):",
"+ if i == self.par[i]:",
"+ def unite(self, child, mas):",
"+ if self.root(child) == self.root(mas):",
"+ return",
"+ else:",
"+ self.par[self.root(child)] = self.root(mas)",
"+",
"+ def root(self, i):",
"+ if self.par[i] == i:",
"+ return i",
"+ else:",
"+ self.par[i] = self.root(self.par[i])",
"+ return self.par[i]",
"+",
"+ def same(self, x, y):",
"+ if self.root(x) == self.root(y):",
"+ return True",
"+ else:",
"+ return False",
"+",
"-uf = UnionFind(n + 1)",
"+uf = uf_tree(n + 1)"
]
| false | 0.046629 | 0.048891 | 0.953732 | [
"s469066539",
"s683677804"
]
|
u282228874 | p03266 | python | s407970159 | s560214856 | 113 | 17 | 3,060 | 2,940 | Accepted | Accepted | 84.96 | n,k = list(map(int,input().split()))
cnt = 0
cnt2 = 0
for i in range(1,n+1):
if k%2 == 0:
if i%k == 0:
cnt += 1
if i%k == k//2:
cnt2 += 1
else:
if i%k == 0:
cnt += 1
print((cnt**3+cnt2**3)) | n,k = list(map(int,input().split()))
if k%2 == 0:
print(((n//k)**3+(n//(k//2)-n//k)**3))
else:
print(((n//k)**3)) | 13 | 5 | 262 | 115 | n, k = list(map(int, input().split()))
cnt = 0
cnt2 = 0
for i in range(1, n + 1):
if k % 2 == 0:
if i % k == 0:
cnt += 1
if i % k == k // 2:
cnt2 += 1
else:
if i % k == 0:
cnt += 1
print((cnt**3 + cnt2**3))
| n, k = list(map(int, input().split()))
if k % 2 == 0:
print(((n // k) ** 3 + (n // (k // 2) - n // k) ** 3))
else:
print(((n // k) ** 3))
| false | 61.538462 | [
"-cnt = 0",
"-cnt2 = 0",
"-for i in range(1, n + 1):",
"- if k % 2 == 0:",
"- if i % k == 0:",
"- cnt += 1",
"- if i % k == k // 2:",
"- cnt2 += 1",
"- else:",
"- if i % k == 0:",
"- cnt += 1",
"-print((cnt**3 + cnt2**3))",
"+if k % 2 == 0:",
"+ print(((n // k) ** 3 + (n // (k // 2) - n // k) ** 3))",
"+else:",
"+ print(((n // k) ** 3))"
]
| false | 0.076916 | 0.03959 | 1.942825 | [
"s407970159",
"s560214856"
]
|
u497952650 | p03854 | python | s021451793 | s141494224 | 20 | 18 | 3,188 | 3,188 | Accepted | Accepted | 10 | S = input()[::-1]
m = ["eraser","erase","dreamer","dream"]
for i in m:
S = S.replace(i[::-1],"")
print(("YES" if S == "" else "NO")) | S = eval(input())
m = ["eraser","erase","dreamer","dream"]
for i in m:
S = S.replace(i,"")
print(("YES" if S == "" else "NO")) | 9 | 9 | 146 | 134 | S = input()[::-1]
m = ["eraser", "erase", "dreamer", "dream"]
for i in m:
S = S.replace(i[::-1], "")
print(("YES" if S == "" else "NO"))
| S = eval(input())
m = ["eraser", "erase", "dreamer", "dream"]
for i in m:
S = S.replace(i, "")
print(("YES" if S == "" else "NO"))
| false | 0 | [
"-S = input()[::-1]",
"+S = eval(input())",
"- S = S.replace(i[::-1], \"\")",
"+ S = S.replace(i, \"\")"
]
| false | 0.109906 | 0.045468 | 2.417246 | [
"s021451793",
"s141494224"
]
|
u735335967 | p03449 | python | s674758914 | s985583362 | 24 | 18 | 3,060 | 3,060 | Accepted | Accepted | 25 | n = int(eval(input()))
a1 = list(map(int, input().split()))
a2 = list(map(int, input().split()))
l = []
cnt = 0
for i in range(1,n+1):
cnt = sum(a1[:i])+sum(a2[i-1:])
l.append(cnt)
cnt = 0
print((max(l)))
| n = int(eval(input()))
a1 = list(map(int, input().split()))
a2 = list(map(int, input().split()))
total = sum(a2)+a1[0]
ans = total
for i in range(1, n):
total = total + a1[i] - a2[i-1]
ans = max(ans, total)
print(ans)
| 11 | 11 | 220 | 232 | n = int(eval(input()))
a1 = list(map(int, input().split()))
a2 = list(map(int, input().split()))
l = []
cnt = 0
for i in range(1, n + 1):
cnt = sum(a1[:i]) + sum(a2[i - 1 :])
l.append(cnt)
cnt = 0
print((max(l)))
| n = int(eval(input()))
a1 = list(map(int, input().split()))
a2 = list(map(int, input().split()))
total = sum(a2) + a1[0]
ans = total
for i in range(1, n):
total = total + a1[i] - a2[i - 1]
ans = max(ans, total)
print(ans)
| false | 0 | [
"-l = []",
"-cnt = 0",
"-for i in range(1, n + 1):",
"- cnt = sum(a1[:i]) + sum(a2[i - 1 :])",
"- l.append(cnt)",
"- cnt = 0",
"-print((max(l)))",
"+total = sum(a2) + a1[0]",
"+ans = total",
"+for i in range(1, n):",
"+ total = total + a1[i] - a2[i - 1]",
"+ ans = max(ans, total)",
"+print(ans)"
]
| false | 0.047266 | 0.102219 | 0.462393 | [
"s674758914",
"s985583362"
]
|
u256464928 | p02850 | python | s851806443 | s015946392 | 1,030 | 896 | 94,872 | 88,824 | Accepted | Accepted | 13.01 | import sys
sys.setrecursionlimit(200000)
N = int(eval(input()))
ans = [0] * (N - 1)
AB = []
for i in range(N-1):
a,b = list(map(int,input().split()))
AB.append([a-1,b-1])
G = [list() for _ in range(N)]
for i in range(N-1):
G[AB[i][1]].append([AB[i][0],i])
G[AB[i][0]].append([AB[i][1],i])
def dfs(v,c = -1,p = -1):
k = 1
for i in range(len(G[v])):
u = G[v][i][0];ei = G[v][i][1]
if u == p:continue
if k == c:
k += 1
ans[ei] = k
k += 1
dfs(u,ans[ei],v)
dfs(0)
mx = 0
for i in range(N):
mx = max(mx,len(G[i]))
print(mx)
for i in range(N-1):
print((ans[i])) | import sys
sys.setrecursionlimit(200000)
N = int(eval(input()))
ans = [0] * (N - 1)
G = [list() for _ in range(N)]
for i in range(N-1):
a,b = list(map(int,input().split()))
a -= 1
b -= 1
G[a].append([b,i])
G[b].append([a,i])
def dfs(v,c = -1,p = -1):
k = 1
for i in range(len(G[v])):
u = G[v][i][0];ei = G[v][i][1]
if u == p:continue
if k == c:
k += 1
ans[ei] = k
k += 1
dfs(u,ans[ei],v)
dfs(0)
mx = 0
for i in range(N):
mx = max(mx,len(G[i]))
print(mx)
for i in range(N-1):
print((ans[i])) | 30 | 33 | 662 | 609 | import sys
sys.setrecursionlimit(200000)
N = int(eval(input()))
ans = [0] * (N - 1)
AB = []
for i in range(N - 1):
a, b = list(map(int, input().split()))
AB.append([a - 1, b - 1])
G = [list() for _ in range(N)]
for i in range(N - 1):
G[AB[i][1]].append([AB[i][0], i])
G[AB[i][0]].append([AB[i][1], i])
def dfs(v, c=-1, p=-1):
k = 1
for i in range(len(G[v])):
u = G[v][i][0]
ei = G[v][i][1]
if u == p:
continue
if k == c:
k += 1
ans[ei] = k
k += 1
dfs(u, ans[ei], v)
dfs(0)
mx = 0
for i in range(N):
mx = max(mx, len(G[i]))
print(mx)
for i in range(N - 1):
print((ans[i]))
| import sys
sys.setrecursionlimit(200000)
N = int(eval(input()))
ans = [0] * (N - 1)
G = [list() for _ in range(N)]
for i in range(N - 1):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
G[a].append([b, i])
G[b].append([a, i])
def dfs(v, c=-1, p=-1):
k = 1
for i in range(len(G[v])):
u = G[v][i][0]
ei = G[v][i][1]
if u == p:
continue
if k == c:
k += 1
ans[ei] = k
k += 1
dfs(u, ans[ei], v)
dfs(0)
mx = 0
for i in range(N):
mx = max(mx, len(G[i]))
print(mx)
for i in range(N - 1):
print((ans[i]))
| false | 9.090909 | [
"-AB = []",
"+G = [list() for _ in range(N)]",
"- AB.append([a - 1, b - 1])",
"-G = [list() for _ in range(N)]",
"-for i in range(N - 1):",
"- G[AB[i][1]].append([AB[i][0], i])",
"- G[AB[i][0]].append([AB[i][1], i])",
"+ a -= 1",
"+ b -= 1",
"+ G[a].append([b, i])",
"+ G[b].append([a, i])"
]
| false | 0.036632 | 0.04487 | 0.816411 | [
"s851806443",
"s015946392"
]
|
u277312083 | p02780 | python | s654071662 | s976416422 | 217 | 189 | 25,060 | 25,060 | Accepted | Accepted | 12.9 | n, k = list(map(int, input().split()))
E = list([(x + 1) * 0.5 for x in list(map(int, input().split()))])
esum = sum(E[:k])
ans = esum
for i in range(n - k):
esum = esum - E[i] + E[i + k]
ans = max(ans, esum)
print(ans)
| n, k = list(map(int, input().split()))
E = list([(x + 1) * 0.5 for x in list(map(int, input().split()))])
e = sum(E[:k])
emax = e
for i in range(k, n):
e += E[i] - E[i - k]
emax = max(e, emax)
print(emax)
| 8 | 8 | 234 | 219 | n, k = list(map(int, input().split()))
E = list([(x + 1) * 0.5 for x in list(map(int, input().split()))])
esum = sum(E[:k])
ans = esum
for i in range(n - k):
esum = esum - E[i] + E[i + k]
ans = max(ans, esum)
print(ans)
| n, k = list(map(int, input().split()))
E = list([(x + 1) * 0.5 for x in list(map(int, input().split()))])
e = sum(E[:k])
emax = e
for i in range(k, n):
e += E[i] - E[i - k]
emax = max(e, emax)
print(emax)
| false | 0 | [
"-esum = sum(E[:k])",
"-ans = esum",
"-for i in range(n - k):",
"- esum = esum - E[i] + E[i + k]",
"- ans = max(ans, esum)",
"-print(ans)",
"+e = sum(E[:k])",
"+emax = e",
"+for i in range(k, n):",
"+ e += E[i] - E[i - k]",
"+ emax = max(e, emax)",
"+print(emax)"
]
| false | 0.044119 | 0.087675 | 0.503213 | [
"s654071662",
"s976416422"
]
|
u285891772 | p03944 | python | s567401812 | s329518970 | 158 | 39 | 13,792 | 5,196 | Accepted | Accepted | 75.32 | import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, log2
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy, copy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
def ZIP(n): return list(zip(*(MAP() for _ in range(n))))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
import numpy as np
W, H, N = MAP()
w, h = np.zeros(W), np.zeros(H)
for _ in range(N):
x, y, a = MAP()
if a == 1:
w[:x] = 1
elif a == 2:
w[x:] = 1
elif a == 3:
h[:y] = 1
elif a == 4:
h[y:] = 1
print((list(w).count(0) * list(h).count(0)))
| import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians#, log2
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy, copy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left, insort, insort_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
def ZIP(n): return list(zip(*(MAP() for _ in range(n))))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
#import numpy as np
#from decimal import *
W, H, N = MAP()
dict = defaultdict(int)
dict[1] = 0
dict[2] = W
dict[3] = 0
dict[4] = H
for _ in range(N):
x, y, a = MAP()
if a == 1:
dict[1] = max(x, dict[1])
elif a == 2:
dict[2] = min(x, dict[2])
elif a == 3:
dict[3] = max(y, dict[3])
elif a == 4:
dict[4] = min(y, dict[4])
if dict[2]-dict[1] < 0 or dict[4]-dict[3] < 0:
print((0))
else:
print((max(0, (dict[2]-dict[1])*(dict[4]-dict[3])))) | 37 | 45 | 1,093 | 1,325 | import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, log2
from itertools import (
accumulate,
permutations,
combinations,
combinations_with_replacement,
product,
groupby,
)
from operator import itemgetter, mul
from copy import deepcopy, copy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
def input():
return sys.stdin.readline().strip()
def INT():
return int(eval(input()))
def MAP():
return list(map(int, input().split()))
def LIST():
return list(map(int, input().split()))
def ZIP(n):
return list(zip(*(MAP() for _ in range(n))))
sys.setrecursionlimit(10**9)
INF = float("inf")
mod = 10**9 + 7
import numpy as np
W, H, N = MAP()
w, h = np.zeros(W), np.zeros(H)
for _ in range(N):
x, y, a = MAP()
if a == 1:
w[:x] = 1
elif a == 2:
w[x:] = 1
elif a == 3:
h[:y] = 1
elif a == 4:
h[y:] = 1
print((list(w).count(0) * list(h).count(0)))
| import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians # , log2
from itertools import (
accumulate,
permutations,
combinations,
combinations_with_replacement,
product,
groupby,
)
from operator import itemgetter, mul
from copy import deepcopy, copy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left, insort, insort_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
def input():
return sys.stdin.readline().strip()
def INT():
return int(eval(input()))
def MAP():
return list(map(int, input().split()))
def LIST():
return list(map(int, input().split()))
def ZIP(n):
return list(zip(*(MAP() for _ in range(n))))
sys.setrecursionlimit(10**9)
INF = float("inf")
mod = 10**9 + 7
# import numpy as np
# from decimal import *
W, H, N = MAP()
dict = defaultdict(int)
dict[1] = 0
dict[2] = W
dict[3] = 0
dict[4] = H
for _ in range(N):
x, y, a = MAP()
if a == 1:
dict[1] = max(x, dict[1])
elif a == 2:
dict[2] = min(x, dict[2])
elif a == 3:
dict[3] = max(y, dict[3])
elif a == 4:
dict[4] = min(y, dict[4])
if dict[2] - dict[1] < 0 or dict[4] - dict[3] < 0:
print((0))
else:
print((max(0, (dict[2] - dict[1]) * (dict[4] - dict[3]))))
| false | 17.777778 | [
"-from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, log2",
"+from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians # , log2",
"-from bisect import bisect, bisect_left",
"+from bisect import bisect, bisect_left, insort, insort_left",
"-import numpy as np",
"-",
"+# import numpy as np",
"+# from decimal import *",
"-w, h = np.zeros(W), np.zeros(H)",
"+dict = defaultdict(int)",
"+dict[1] = 0",
"+dict[2] = W",
"+dict[3] = 0",
"+dict[4] = H",
"- w[:x] = 1",
"+ dict[1] = max(x, dict[1])",
"- w[x:] = 1",
"+ dict[2] = min(x, dict[2])",
"- h[:y] = 1",
"+ dict[3] = max(y, dict[3])",
"- h[y:] = 1",
"-print((list(w).count(0) * list(h).count(0)))",
"+ dict[4] = min(y, dict[4])",
"+if dict[2] - dict[1] < 0 or dict[4] - dict[3] < 0:",
"+ print((0))",
"+else:",
"+ print((max(0, (dict[2] - dict[1]) * (dict[4] - dict[3]))))"
]
| false | 0.654497 | 0.03716 | 17.612822 | [
"s567401812",
"s329518970"
]
|
u977389981 | p03624 | python | s733193302 | s394130887 | 22 | 17 | 3,188 | 3,188 | Accepted | Accepted | 22.73 | abc = set('abcdefghijklmnopqrstuvwxyz')
S = set(eval(input()))
print((sorted(abc - S)[0] if len(abc - S) != 0 else None)) | alfa = 'abcdefghijklmnopqrstuvwxyz'
S = eval(input())
for i in range(len(alfa)):
if alfa[i] not in S:
print((alfa[i]))
break
else:
print('None') | 4 | 8 | 117 | 167 | abc = set("abcdefghijklmnopqrstuvwxyz")
S = set(eval(input()))
print((sorted(abc - S)[0] if len(abc - S) != 0 else None))
| alfa = "abcdefghijklmnopqrstuvwxyz"
S = eval(input())
for i in range(len(alfa)):
if alfa[i] not in S:
print((alfa[i]))
break
else:
print("None")
| false | 50 | [
"-abc = set(\"abcdefghijklmnopqrstuvwxyz\")",
"-S = set(eval(input()))",
"-print((sorted(abc - S)[0] if len(abc - S) != 0 else None))",
"+alfa = \"abcdefghijklmnopqrstuvwxyz\"",
"+S = eval(input())",
"+for i in range(len(alfa)):",
"+ if alfa[i] not in S:",
"+ print((alfa[i]))",
"+ break",
"+else:",
"+ print(\"None\")"
]
| false | 0.245288 | 0.081118 | 3.023857 | [
"s733193302",
"s394130887"
]
|
u759412327 | p03557 | python | s353999971 | s194674585 | 306 | 217 | 22,720 | 29,076 | Accepted | Accepted | 29.08 | import bisect
n = int(eval(input()))
a,b,c = [sorted(map(int,input().split())) for _ in "abc"]
print((sum([bisect.bisect_left(a,x)*(n-bisect.bisect_right(c,x)) for x in b]))) | from bisect import *
N = int(eval(input()))
A = sorted(list(map(int,input().split())))
B = sorted(list(map(int,input().split())))
C = sorted(list(map(int,input().split())))
print((sum(bisect_left(A,b)*(N-bisect_right(C,b)) for b in B))) | 4 | 6 | 169 | 233 | import bisect
n = int(eval(input()))
a, b, c = [sorted(map(int, input().split())) for _ in "abc"]
print((sum([bisect.bisect_left(a, x) * (n - bisect.bisect_right(c, x)) for x in b])))
| from bisect import *
N = int(eval(input()))
A = sorted(list(map(int, input().split())))
B = sorted(list(map(int, input().split())))
C = sorted(list(map(int, input().split())))
print((sum(bisect_left(A, b) * (N - bisect_right(C, b)) for b in B)))
| false | 33.333333 | [
"-import bisect",
"+from bisect import *",
"-n = int(eval(input()))",
"-a, b, c = [sorted(map(int, input().split())) for _ in \"abc\"]",
"-print((sum([bisect.bisect_left(a, x) * (n - bisect.bisect_right(c, x)) for x in b])))",
"+N = int(eval(input()))",
"+A = sorted(list(map(int, input().split())))",
"+B = sorted(list(map(int, input().split())))",
"+C = sorted(list(map(int, input().split())))",
"+print((sum(bisect_left(A, b) * (N - bisect_right(C, b)) for b in B)))"
]
| false | 0.121502 | 0.045919 | 2.646038 | [
"s353999971",
"s194674585"
]
|
u223663729 | p02579 | python | s199897650 | s595151019 | 1,062 | 689 | 92,256 | 86,948 | Accepted | Accepted | 35.12 | from heapq import heapify, heappop, heappush
import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
input = sys.stdin.readline
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
S = [input().rstrip() for _ in [0]*H]
INF = 10**10
D = [[INF]*W for _ in [0]*H]
used = set()
q = []
heappush(q, (0, Ch*W+Cw))
while q:
d, ij = heappop(q)
i, j = divmod(ij, W)
for di in range(-2, 3):
for dj in range(-2, 3):
if di == dj == 0:
continue
I = i+di; J = j+dj
if 0 <= I < H and 0 <= J < W and S[I][J] == '.':
if abs(di)+abs(dj) == 1:
if D[I][J] <= d:
continue
D[I][J] = d
heappush(q, (d, I*W+J))
else:
if D[I][J] <= d+1:
continue
D[I][J] = d+1
heappush(q, (d+1, I*W+J))
ans = D[Dh][Dw]
print((ans if ans < INF else -1))
| from collections import deque
import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
input = sys.stdin.readline
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
S = [input().rstrip() for _ in [0]*H]
INF = 10**10
D = [[INF]*W for _ in [0]*H]
used = set()
q = deque()
q.append((0, Ch*W+Cw))
while q:
d, ij = q.popleft()
i, j = divmod(ij, W)
for di in range(-2, 3):
for dj in range(-2, 3):
if di == dj == 0:
continue
I = i+di
J = j+dj
if 0 <= I < H and 0 <= J < W and S[I][J] == '.':
if abs(di)+abs(dj) == 1:
if D[I][J] <= d:
continue
D[I][J] = d
q.appendleft((d, I*W+J))
else:
if D[I][J] <= d+1:
continue
D[I][J] = d+1
q.append((d+1, I*W+J))
ans = D[Dh][Dw]
print((ans if ans < INF else -1)) | 46 | 46 | 1,123 | 1,118 | from heapq import heapify, heappop, heappush
import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
input = sys.stdin.readline
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
S = [input().rstrip() for _ in [0] * H]
INF = 10**10
D = [[INF] * W for _ in [0] * H]
used = set()
q = []
heappush(q, (0, Ch * W + Cw))
while q:
d, ij = heappop(q)
i, j = divmod(ij, W)
for di in range(-2, 3):
for dj in range(-2, 3):
if di == dj == 0:
continue
I = i + di
J = j + dj
if 0 <= I < H and 0 <= J < W and S[I][J] == ".":
if abs(di) + abs(dj) == 1:
if D[I][J] <= d:
continue
D[I][J] = d
heappush(q, (d, I * W + J))
else:
if D[I][J] <= d + 1:
continue
D[I][J] = d + 1
heappush(q, (d + 1, I * W + J))
ans = D[Dh][Dw]
print((ans if ans < INF else -1))
| from collections import deque
import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
input = sys.stdin.readline
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
S = [input().rstrip() for _ in [0] * H]
INF = 10**10
D = [[INF] * W for _ in [0] * H]
used = set()
q = deque()
q.append((0, Ch * W + Cw))
while q:
d, ij = q.popleft()
i, j = divmod(ij, W)
for di in range(-2, 3):
for dj in range(-2, 3):
if di == dj == 0:
continue
I = i + di
J = j + dj
if 0 <= I < H and 0 <= J < W and S[I][J] == ".":
if abs(di) + abs(dj) == 1:
if D[I][J] <= d:
continue
D[I][J] = d
q.appendleft((d, I * W + J))
else:
if D[I][J] <= d + 1:
continue
D[I][J] = d + 1
q.append((d + 1, I * W + J))
ans = D[Dh][Dw]
print((ans if ans < INF else -1))
| false | 0 | [
"-from heapq import heapify, heappop, heappush",
"+from collections import deque",
"-q = []",
"-heappush(q, (0, Ch * W + Cw))",
"+q = deque()",
"+q.append((0, Ch * W + Cw))",
"- d, ij = heappop(q)",
"+ d, ij = q.popleft()",
"- heappush(q, (d, I * W + J))",
"+ q.appendleft((d, I * W + J))",
"- heappush(q, (d + 1, I * W + J))",
"+ q.append((d + 1, I * W + J))"
]
| false | 0.045866 | 0.046757 | 0.980936 | [
"s199897650",
"s595151019"
]
|
u297574184 | p02755 | python | s026500362 | s022790703 | 33 | 17 | 2,940 | 3,060 | Accepted | Accepted | 48.48 | A, B = list(map(int, input().split()))
for x in range(1, 10**5):
if x*8//100 == A and x*10//100 == B:
print(x)
break
else:
print((-1))
| A, B = list(map(int, input().split()))
L1, R1 = -(-(100*A) // 8), -(-(100*(A+1)) // 8) - 1
L2, R2 = -(-(100*B) // 10), -(-(100*(B+1)) // 10) - 1
L = max(L1, L2)
R = min(R1, R2)
if L <= R:
print(L)
else:
print((-1))
| 8 | 11 | 159 | 227 | A, B = list(map(int, input().split()))
for x in range(1, 10**5):
if x * 8 // 100 == A and x * 10 // 100 == B:
print(x)
break
else:
print((-1))
| A, B = list(map(int, input().split()))
L1, R1 = -(-(100 * A) // 8), -(-(100 * (A + 1)) // 8) - 1
L2, R2 = -(-(100 * B) // 10), -(-(100 * (B + 1)) // 10) - 1
L = max(L1, L2)
R = min(R1, R2)
if L <= R:
print(L)
else:
print((-1))
| false | 27.272727 | [
"-for x in range(1, 10**5):",
"- if x * 8 // 100 == A and x * 10 // 100 == B:",
"- print(x)",
"- break",
"+L1, R1 = -(-(100 * A) // 8), -(-(100 * (A + 1)) // 8) - 1",
"+L2, R2 = -(-(100 * B) // 10), -(-(100 * (B + 1)) // 10) - 1",
"+L = max(L1, L2)",
"+R = min(R1, R2)",
"+if L <= R:",
"+ print(L)"
]
| false | 0.04377 | 0.075373 | 0.580707 | [
"s026500362",
"s022790703"
]
|
u297574184 | p02768 | python | s255895323 | s925512631 | 239 | 105 | 10,904 | 9,148 | Accepted | Accepted | 56.07 | MOD = 10**9 + 7
n, a, b = list(map(int, input().split()))
ans = pow(2, n, MOD) - 1
# invs[x]: xの逆元 (x:0～n)
def getInvs(n, MOD):
invs = [1] * (n+1)
for x in range(2, n+1):
invs[x] = (-(MOD//x) * invs[MOD%x]) % MOD
return invs
invs = getInvs(2*10**5, MOD)
def f(n, k):
num = 1
for i in range(n-k+1, n+1):
num *= i
num %= MOD
for i in range(k+1):
num *= invs[i]
num %= MOD
return num
numA = f(n, a)
numB = f(n, b)
#print('numA:', numA, '/ numB:', numB)
print(((ans - numA - numB) % MOD))
| MOD = 10**9 + 7
N, A, B = list(map(int, input().split()))
def getComb(n, k, MOD):
if n < k:
return 0
if n-k < k:
k = n-k
comb = 1
for x in range(n-k+1, n+1):
comb = (comb * x) % MOD
d = 1
for x in range(1, k+1):
d = (d * x) % MOD
comb *= pow(d, MOD-2, MOD)
return comb % MOD
ans = pow(2, N, MOD) - 1
ans -= getComb(N, A, MOD)
ans -= getComb(N, B, MOD)
ans %= MOD
print(ans)
| 30 | 24 | 581 | 459 | MOD = 10**9 + 7
n, a, b = list(map(int, input().split()))
ans = pow(2, n, MOD) - 1
# invs[x]: xの逆元 (x:0～n)
def getInvs(n, MOD):
invs = [1] * (n + 1)
for x in range(2, n + 1):
invs[x] = (-(MOD // x) * invs[MOD % x]) % MOD
return invs
invs = getInvs(2 * 10**5, MOD)
def f(n, k):
num = 1
for i in range(n - k + 1, n + 1):
num *= i
num %= MOD
for i in range(k + 1):
num *= invs[i]
num %= MOD
return num
numA = f(n, a)
numB = f(n, b)
# print('numA:', numA, '/ numB:', numB)
print(((ans - numA - numB) % MOD))
| MOD = 10**9 + 7
N, A, B = list(map(int, input().split()))
def getComb(n, k, MOD):
if n < k:
return 0
if n - k < k:
k = n - k
comb = 1
for x in range(n - k + 1, n + 1):
comb = (comb * x) % MOD
d = 1
for x in range(1, k + 1):
d = (d * x) % MOD
comb *= pow(d, MOD - 2, MOD)
return comb % MOD
ans = pow(2, N, MOD) - 1
ans -= getComb(N, A, MOD)
ans -= getComb(N, B, MOD)
ans %= MOD
print(ans)
| false | 20 | [
"-n, a, b = list(map(int, input().split()))",
"-ans = pow(2, n, MOD) - 1",
"-# invs[x]: xの逆元 (x:0～n)",
"-def getInvs(n, MOD):",
"- invs = [1] * (n + 1)",
"- for x in range(2, n + 1):",
"- invs[x] = (-(MOD // x) * invs[MOD % x]) % MOD",
"- return invs",
"+N, A, B = list(map(int, input().split()))",
"-invs = getInvs(2 * 10**5, MOD)",
"+def getComb(n, k, MOD):",
"+ if n < k:",
"+ return 0",
"+ if n - k < k:",
"+ k = n - k",
"+ comb = 1",
"+ for x in range(n - k + 1, n + 1):",
"+ comb = (comb * x) % MOD",
"+ d = 1",
"+ for x in range(1, k + 1):",
"+ d = (d * x) % MOD",
"+ comb *= pow(d, MOD - 2, MOD)",
"+ return comb % MOD",
"-def f(n, k):",
"- num = 1",
"- for i in range(n - k + 1, n + 1):",
"- num *= i",
"- num %= MOD",
"- for i in range(k + 1):",
"- num *= invs[i]",
"- num %= MOD",
"- return num",
"-",
"-",
"-numA = f(n, a)",
"-numB = f(n, b)",
"-# print('numA:', numA, '/ numB:', numB)",
"-print(((ans - numA - numB) % MOD))",
"+ans = pow(2, N, MOD) - 1",
"+ans -= getComb(N, A, MOD)",
"+ans -= getComb(N, B, MOD)",
"+ans %= MOD",
"+print(ans)"
]
| false | 0.253145 | 0.153497 | 1.649189 | [
"s255895323",
"s925512631"
]
|
u764956288 | p02691 | python | s494148715 | s903819799 | 114 | 104 | 32,224 | 32,296 | Accepted | Accepted | 8.77 | def main():
N = int(eval(input()))
heights = list(map(int, input().split()))
"""
for j>i, j-i = Ai + Aj
i + Ai = j -Aj
"""
L = [0] * N
R = [0] * N
count = 0
for i, height in enumerate(heights):
right = i + height
left = i - height
if right < N:
R[right] += 1
if left > 0:
L[left] += 1
count += R[left]
print(count)
if __name__ == "__main__":
main()
| def main():
N = int(eval(input()))
heights = list(map(int, input().split()))
"""
for j>i, j-i = Ai + Aj
-> i + Ai = j -Aj
"""
x = [0] * N # x represents i + Ai
count = 0
for i, height in enumerate(heights):
right = i + height
left = i - height
if right < N:
x[right] += 1
if left > 0:
count += x[left]
print(count)
if __name__ == "__main__":
main()
| 29 | 27 | 495 | 478 | def main():
N = int(eval(input()))
heights = list(map(int, input().split()))
"""
for j>i, j-i = Ai + Aj
i + Ai = j -Aj
"""
L = [0] * N
R = [0] * N
count = 0
for i, height in enumerate(heights):
right = i + height
left = i - height
if right < N:
R[right] += 1
if left > 0:
L[left] += 1
count += R[left]
print(count)
if __name__ == "__main__":
main()
| def main():
N = int(eval(input()))
heights = list(map(int, input().split()))
"""
for j>i, j-i = Ai + Aj
-> i + Ai = j -Aj
"""
x = [0] * N # x represents i + Ai
count = 0
for i, height in enumerate(heights):
right = i + height
left = i - height
if right < N:
x[right] += 1
if left > 0:
count += x[left]
print(count)
if __name__ == "__main__":
main()
| false | 6.896552 | [
"- i + Ai = j -Aj",
"+ -> i + Ai = j -Aj",
"- L = [0] * N",
"- R = [0] * N",
"+ x = [0] * N # x represents i + Ai",
"- R[right] += 1",
"+ x[right] += 1",
"- L[left] += 1",
"- count += R[left]",
"+ count += x[left]"
]
| false | 0.044356 | 0.093888 | 0.472431 | [
"s494148715",
"s903819799"
]
|
u811512248 | p03081 | python | s886019560 | s744015358 | 1,682 | 470 | 39,348 | 40,892 | Accepted | Accepted | 72.06 | N, Q = list(map(int, input().split()))
s = eval(input())
spells = [input().split() for i in range(Q)]
def sim(pos, s, spells, N):
for sp in spells:
if s[pos] == sp[0]:
pos += -1 if sp[1] == "L" else 1
if pos < 0:
return "LDead"
if pos >= N:
return "RDead"
return "Alive"
#LD探し
Lpos = -1
Rpos = N
while Lpos+1<Rpos:
pos = (Lpos+Rpos)//2
if sim(pos, s, spells, N) == "LDead":
Lpos = pos
else:
Rpos = pos
LDpos = Lpos ###LDeadの中で一番境界に近いもの
#RD探し
Lpos = -1
Rpos = N
while Lpos+1<Rpos:
pos = (Lpos+Rpos)//2
if sim(pos, s, spells, N) == "RDead":
Rpos = pos
else:
Lpos = pos
RDpos = Rpos ###RDeadの中で一番境界に近いもの
print((max(0,RDpos-LDpos-1))) | N, Q = list(map(int, input().split()))
s = eval(input())
spells = [input().split() for i in range(Q)]
### 逆順で落ちるゴーレムの位置を戻す
#落ちるゴーレムの端の位置
LDpos = -1
RDpos = N
for sp in spells[::-1]:
if sp[1] == "L":
if LDpos < N-1 and s[LDpos+1] == sp[0]:
LDpos +=1 #LDposのゴーレムは1spell前には一つ右に居た
if RDpos <= N-1 and s[RDpos] == sp[0]:
RDpos +=1 #RDposの一つ左(生き残りの右端)は1spell前にこのマスに居れるので境界が一つ戻る
else:
if LDpos >= 0 and s[LDpos] == sp[0]:
LDpos -=1 #LDposの一つ右(生き残りの左端)は1spell前にこのマスに居れるので境界が一つ戻る
if RDpos > 0 and s[RDpos-1] == sp[0]:
RDpos -= 1 #RDposのゴーレムは1spell前には一つ左に居た
print((max(RDpos-LDpos-1,0))) | 37 | 19 | 803 | 676 | N, Q = list(map(int, input().split()))
s = eval(input())
spells = [input().split() for i in range(Q)]
def sim(pos, s, spells, N):
for sp in spells:
if s[pos] == sp[0]:
pos += -1 if sp[1] == "L" else 1
if pos < 0:
return "LDead"
if pos >= N:
return "RDead"
return "Alive"
# LD探し
Lpos = -1
Rpos = N
while Lpos + 1 < Rpos:
pos = (Lpos + Rpos) // 2
if sim(pos, s, spells, N) == "LDead":
Lpos = pos
else:
Rpos = pos
LDpos = Lpos ###LDeadの中で一番境界に近いもの
# RD探し
Lpos = -1
Rpos = N
while Lpos + 1 < Rpos:
pos = (Lpos + Rpos) // 2
if sim(pos, s, spells, N) == "RDead":
Rpos = pos
else:
Lpos = pos
RDpos = Rpos ###RDeadの中で一番境界に近いもの
print((max(0, RDpos - LDpos - 1)))
| N, Q = list(map(int, input().split()))
s = eval(input())
spells = [input().split() for i in range(Q)]
### 逆順で落ちるゴーレムの位置を戻す
# 落ちるゴーレムの端の位置
LDpos = -1
RDpos = N
for sp in spells[::-1]:
if sp[1] == "L":
if LDpos < N - 1 and s[LDpos + 1] == sp[0]:
LDpos += 1 # LDposのゴーレムは1spell前には一つ右に居た
if RDpos <= N - 1 and s[RDpos] == sp[0]:
RDpos += 1 # RDposの一つ左(生き残りの右端)は1spell前にこのマスに居れるので境界が一つ戻る
else:
if LDpos >= 0 and s[LDpos] == sp[0]:
LDpos -= 1 # LDposの一つ右(生き残りの左端)は1spell前にこのマスに居れるので境界が一つ戻る
if RDpos > 0 and s[RDpos - 1] == sp[0]:
RDpos -= 1 # RDposのゴーレムは1spell前には一つ左に居た
print((max(RDpos - LDpos - 1, 0)))
| false | 48.648649 | [
"-",
"-",
"-def sim(pos, s, spells, N):",
"- for sp in spells:",
"- if s[pos] == sp[0]:",
"- pos += -1 if sp[1] == \"L\" else 1",
"- if pos < 0:",
"- return \"LDead\"",
"- if pos >= N:",
"- return \"RDead\"",
"- return \"Alive\"",
"-",
"-",
"-# LD探し",
"-Lpos = -1",
"-Rpos = N",
"-while Lpos + 1 < Rpos:",
"- pos = (Lpos + Rpos) // 2",
"- if sim(pos, s, spells, N) == \"LDead\":",
"- Lpos = pos",
"+### 逆順で落ちるゴーレムの位置を戻す",
"+# 落ちるゴーレムの端の位置",
"+LDpos = -1",
"+RDpos = N",
"+for sp in spells[::-1]:",
"+ if sp[1] == \"L\":",
"+ if LDpos < N - 1 and s[LDpos + 1] == sp[0]:",
"+ LDpos += 1 # LDposのゴーレムは1spell前には一つ右に居た",
"+ if RDpos <= N - 1 and s[RDpos] == sp[0]:",
"+ RDpos += 1 # RDposの一つ左(生き残りの右端)は1spell前にこのマスに居れるので境界が一つ戻る",
"- Rpos = pos",
"-LDpos = Lpos ###LDeadの中で一番境界に近いもの",
"-# RD探し",
"-Lpos = -1",
"-Rpos = N",
"-while Lpos + 1 < Rpos:",
"- pos = (Lpos + Rpos) // 2",
"- if sim(pos, s, spells, N) == \"RDead\":",
"- Rpos = pos",
"- else:",
"- Lpos = pos",
"-RDpos = Rpos ###RDeadの中で一番境界に近いもの",
"-print((max(0, RDpos - LDpos - 1)))",
"+ if LDpos >= 0 and s[LDpos] == sp[0]:",
"+ LDpos -= 1 # LDposの一つ右(生き残りの左端)は1spell前にこのマスに居れるので境界が一つ戻る",
"+ if RDpos > 0 and s[RDpos - 1] == sp[0]:",
"+ RDpos -= 1 # RDposのゴーレムは1spell前には一つ左に居た",
"+print((max(RDpos - LDpos - 1, 0)))"
]
| false | 0.082622 | 0.038423 | 2.150311 | [
"s886019560",
"s744015358"
]
|
u868701750 | p02773 | python | s018593150 | s971923355 | 494 | 353 | 35,940 | 35,936 | Accepted | Accepted | 28.54 | def main():
from collections import Counter
N = int(eval(input()))
S = [eval(input()) for _ in range(N)]
c = Counter(S)
_max = max(c.values())
keys = [k for k, v in list(c.items()) if v == _max]
print(('\n'.join(sorted(keys))))
if __name__ == '__main__':
main()
| def main():
import sys
from collections import Counter
N = int(eval(input()))
S = [sys.stdin.readline().rstrip('\n') for _ in range(N)]
c = Counter(S)
_max = max(c.values())
keys = [k for k, v in list(c.items()) if v == _max]
print(('\n'.join(sorted(keys))))
if __name__ == '__main__':
main() | 14 | 13 | 291 | 328 | def main():
from collections import Counter
N = int(eval(input()))
S = [eval(input()) for _ in range(N)]
c = Counter(S)
_max = max(c.values())
keys = [k for k, v in list(c.items()) if v == _max]
print(("\n".join(sorted(keys))))
if __name__ == "__main__":
main()
| def main():
import sys
from collections import Counter
N = int(eval(input()))
S = [sys.stdin.readline().rstrip("\n") for _ in range(N)]
c = Counter(S)
_max = max(c.values())
keys = [k for k, v in list(c.items()) if v == _max]
print(("\n".join(sorted(keys))))
if __name__ == "__main__":
main()
| false | 7.142857 | [
"+ import sys",
"- S = [eval(input()) for _ in range(N)]",
"+ S = [sys.stdin.readline().rstrip(\"\\n\") for _ in range(N)]"
]
| false | 0.041022 | 0.037964 | 1.08055 | [
"s018593150",
"s971923355"
]
|
u145950990 | p03221 | python | s440570127 | s001830963 | 889 | 504 | 90,456 | 48,528 | Accepted | Accepted | 43.31 | from collections import defaultdict
n,m = list(map(int,input().split()))
py = []
for i in range(m):
p,y = list(map(int,input().split()))
py.append([p,y])
spy = sorted(py,key=lambda x:x[1])
cnt = [0]*n
id = defaultdict(int)
for i in spy:
p,y = i
cnt[p-1] += 1
id[(p,y)] = str(p).zfill(6)+str(cnt[p-1]).zfill(6)
for i in py:
p,y = i
print((id[(p,y)])) | n,m = list(map(int,input().split()))
py = [list(map(int,input().split())) for i in range(m)]
c = [0]*n
sort_py = sorted(py,key=lambda x:x[1])
ans = dict()
for p,y in sort_py:
c[p-1] += 1
ans[p,y] = str(p).zfill(6)+str(c[p-1]).zfill(6)
for p,y in py:
print((ans[p,y])) | 18 | 11 | 384 | 282 | from collections import defaultdict
n, m = list(map(int, input().split()))
py = []
for i in range(m):
p, y = list(map(int, input().split()))
py.append([p, y])
spy = sorted(py, key=lambda x: x[1])
cnt = [0] * n
id = defaultdict(int)
for i in spy:
p, y = i
cnt[p - 1] += 1
id[(p, y)] = str(p).zfill(6) + str(cnt[p - 1]).zfill(6)
for i in py:
p, y = i
print((id[(p, y)]))
| n, m = list(map(int, input().split()))
py = [list(map(int, input().split())) for i in range(m)]
c = [0] * n
sort_py = sorted(py, key=lambda x: x[1])
ans = dict()
for p, y in sort_py:
c[p - 1] += 1
ans[p, y] = str(p).zfill(6) + str(c[p - 1]).zfill(6)
for p, y in py:
print((ans[p, y]))
| false | 38.888889 | [
"-from collections import defaultdict",
"-",
"-py = []",
"-for i in range(m):",
"- p, y = list(map(int, input().split()))",
"- py.append([p, y])",
"-spy = sorted(py, key=lambda x: x[1])",
"-cnt = [0] * n",
"-id = defaultdict(int)",
"-for i in spy:",
"- p, y = i",
"- cnt[p - 1] += 1",
"- id[(p, y)] = str(p).zfill(6) + str(cnt[p - 1]).zfill(6)",
"-for i in py:",
"- p, y = i",
"- print((id[(p, y)]))",
"+py = [list(map(int, input().split())) for i in range(m)]",
"+c = [0] * n",
"+sort_py = sorted(py, key=lambda x: x[1])",
"+ans = dict()",
"+for p, y in sort_py:",
"+ c[p - 1] += 1",
"+ ans[p, y] = str(p).zfill(6) + str(c[p - 1]).zfill(6)",
"+for p, y in py:",
"+ print((ans[p, y]))"
]
| false | 0.040016 | 0.035397 | 1.130478 | [
"s440570127",
"s001830963"
]
|
u691018832 | p03147 | python | s941798228 | s851064293 | 21 | 17 | 3,316 | 3,064 | Accepted | Accepted | 19.05 | n = int(eval(input()))
h = list(map(int,input().split()))
ans = 0
check = 0
for i in h:
if check < i:
ans += i-check
check = i
print(ans)
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
n, *h = list(map(int, read().split()))
ans = 0
flag = False
for bf, af in zip(h, h[1:]):
if bf <= af:
if flag:
ans += t - bf
flag = False
else:
if not flag:
t = bf
flag = True
if flag:
ans += t
else:
ans += h[-1]
print(ans)
| 11 | 23 | 160 | 460 | n = int(eval(input()))
h = list(map(int, input().split()))
ans = 0
check = 0
for i in h:
if check < i:
ans += i - check
check = i
print(ans)
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10**7)
n, *h = list(map(int, read().split()))
ans = 0
flag = False
for bf, af in zip(h, h[1:]):
if bf <= af:
if flag:
ans += t - bf
flag = False
else:
if not flag:
t = bf
flag = True
if flag:
ans += t
else:
ans += h[-1]
print(ans)
| false | 52.173913 | [
"-n = int(eval(input()))",
"-h = list(map(int, input().split()))",
"+import sys",
"+",
"+read = sys.stdin.buffer.read",
"+readline = sys.stdin.buffer.readline",
"+readlines = sys.stdin.buffer.readlines",
"+sys.setrecursionlimit(10**7)",
"+n, *h = list(map(int, read().split()))",
"-check = 0",
"-for i in h:",
"- if check < i:",
"- ans += i - check",
"- check = i",
"+flag = False",
"+for bf, af in zip(h, h[1:]):",
"+ if bf <= af:",
"+ if flag:",
"+ ans += t - bf",
"+ flag = False",
"+ else:",
"+ if not flag:",
"+ t = bf",
"+ flag = True",
"+if flag:",
"+ ans += t",
"+else:",
"+ ans += h[-1]"
]
| false | 0.047487 | 0.041767 | 1.136935 | [
"s941798228",
"s851064293"
]
|
u321605735 | p03030 | python | s873722315 | s018693338 | 31 | 26 | 9,236 | 9,240 | Accepted | Accepted | 16.13 | N=int(eval(input()))
data=[input().split() for i in range(N)]
data_name=[]
for i in range(N):
if data[i][0] in data_name:
continue
else:
data_name.append(data[i][0])
data_name_sort=sorted(data_name)
#print(data_name_sort)
data_point=[]
for i in range(N):
num=0
for j in range(len(data_name_sort)):
if data[i][0]==data_name_sort[j]:
num+=(len(data_name)-j)*200+int(data[i][1])
else:
continue
data_point.append(num)
#print(data_point)
data_sort=[i for i, _ in sorted(enumerate(data_point), key=lambda x:x[1])][::-1]
#print(data_sort)
for i in range(N):
ans=int(data_sort[i])+1
print(ans) | N=int(eval(input()))
d=[input().split() for i in range(N)]
name=[]
for i in range(N):
d[i].append(i+1)
d[i][1]=int(d[i][1])
name.append(d[i][0])
Name=list(set(name))
Name.sort()
d.sort()
for i in range(len(Name)):
li=[]
for j in range(N):
if Name[i]==d[j][0]:
li.append([d[j][1],d[j][2]])
else:
continue
li.sort()
Li=li[::-1]
for k in range(len(li)):
print((Li[k][1])) | 25 | 21 | 687 | 460 | N = int(eval(input()))
data = [input().split() for i in range(N)]
data_name = []
for i in range(N):
if data[i][0] in data_name:
continue
else:
data_name.append(data[i][0])
data_name_sort = sorted(data_name)
# print(data_name_sort)
data_point = []
for i in range(N):
num = 0
for j in range(len(data_name_sort)):
if data[i][0] == data_name_sort[j]:
num += (len(data_name) - j) * 200 + int(data[i][1])
else:
continue
data_point.append(num)
# print(data_point)
data_sort = [i for i, _ in sorted(enumerate(data_point), key=lambda x: x[1])][::-1]
# print(data_sort)
for i in range(N):
ans = int(data_sort[i]) + 1
print(ans)
| N = int(eval(input()))
d = [input().split() for i in range(N)]
name = []
for i in range(N):
d[i].append(i + 1)
d[i][1] = int(d[i][1])
name.append(d[i][0])
Name = list(set(name))
Name.sort()
d.sort()
for i in range(len(Name)):
li = []
for j in range(N):
if Name[i] == d[j][0]:
li.append([d[j][1], d[j][2]])
else:
continue
li.sort()
Li = li[::-1]
for k in range(len(li)):
print((Li[k][1]))
| false | 16 | [
"-data = [input().split() for i in range(N)]",
"-data_name = []",
"+d = [input().split() for i in range(N)]",
"+name = []",
"- if data[i][0] in data_name:",
"- continue",
"- else:",
"- data_name.append(data[i][0])",
"-data_name_sort = sorted(data_name)",
"-# print(data_name_sort)",
"-data_point = []",
"-for i in range(N):",
"- num = 0",
"- for j in range(len(data_name_sort)):",
"- if data[i][0] == data_name_sort[j]:",
"- num += (len(data_name) - j) * 200 + int(data[i][1])",
"+ d[i].append(i + 1)",
"+ d[i][1] = int(d[i][1])",
"+ name.append(d[i][0])",
"+Name = list(set(name))",
"+Name.sort()",
"+d.sort()",
"+for i in range(len(Name)):",
"+ li = []",
"+ for j in range(N):",
"+ if Name[i] == d[j][0]:",
"+ li.append([d[j][1], d[j][2]])",
"- data_point.append(num)",
"-# print(data_point)",
"-data_sort = [i for i, _ in sorted(enumerate(data_point), key=lambda x: x[1])][::-1]",
"-# print(data_sort)",
"-for i in range(N):",
"- ans = int(data_sort[i]) + 1",
"- print(ans)",
"+ li.sort()",
"+ Li = li[::-1]",
"+ for k in range(len(li)):",
"+ print((Li[k][1]))"
]
| false | 0.111292 | 0.158185 | 0.703558 | [
"s873722315",
"s018693338"
]
|
u130900604 | p02756 | python | s195349387 | s486846962 | 1,807 | 678 | 4,668 | 10,612 | Accepted | Accepted | 62.48 | s=eval(input())
q=int(eval(input()))
l=""
r=""
flg=True
for i in range(q):
p=list(map(str,input().split()))
if p[0]=="1":
flg=not flg
else:
z,f,c=p
if f=="1":
if flg:
l=c+l
else:
r=r+c
else:
if not flg:
l=c+l
else:
r=r+c
s=l+s+r
if flg:
ans=s
else:
ans=s[::-1]
print(ans) | from collections import deque
s=deque(eval(input()))
q=int(eval(input()))
flg=True #正順
for i in range(q):
p=list(map(str,input().split()))
if p[0]=="1":flg=not(flg)
else:
z,f,c=p
if f=="1":
if flg:s.appendleft(c)
else:s.append(c)
else:
if not(flg):s.appendleft(c)
else:s.append(c)
s=list(s)
if flg:
ans=s
else:
ans=s[::-1]
print(("".join(ans)))
| 29 | 23 | 453 | 447 | s = eval(input())
q = int(eval(input()))
l = ""
r = ""
flg = True
for i in range(q):
p = list(map(str, input().split()))
if p[0] == "1":
flg = not flg
else:
z, f, c = p
if f == "1":
if flg:
l = c + l
else:
r = r + c
else:
if not flg:
l = c + l
else:
r = r + c
s = l + s + r
if flg:
ans = s
else:
ans = s[::-1]
print(ans)
| from collections import deque
s = deque(eval(input()))
q = int(eval(input()))
flg = True # 正順
for i in range(q):
p = list(map(str, input().split()))
if p[0] == "1":
flg = not (flg)
else:
z, f, c = p
if f == "1":
if flg:
s.appendleft(c)
else:
s.append(c)
else:
if not (flg):
s.appendleft(c)
else:
s.append(c)
s = list(s)
if flg:
ans = s
else:
ans = s[::-1]
print(("".join(ans)))
| false | 20.689655 | [
"-s = eval(input())",
"+from collections import deque",
"+",
"+s = deque(eval(input()))",
"-l = \"\"",
"-r = \"\"",
"-flg = True",
"+flg = True # 正順",
"- flg = not flg",
"+ flg = not (flg)",
"- l = c + l",
"+ s.appendleft(c)",
"- r = r + c",
"+ s.append(c)",
"- if not flg:",
"- l = c + l",
"+ if not (flg):",
"+ s.appendleft(c)",
"- r = r + c",
"-s = l + s + r",
"+ s.append(c)",
"+s = list(s)",
"-print(ans)",
"+print((\"\".join(ans)))"
]
| false | 0.042148 | 0.046782 | 0.900952 | [
"s195349387",
"s486846962"
]
|
u287500079 | p02741 | python | s080817580 | s371346511 | 134 | 39 | 5,968 | 5,144 | Accepted | Accepted | 70.9 | import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd
def input(): return sys.stdin.readline().strip()
def STR(): return eval(input())
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def S_MAP(): return list(map(str, input().split()))
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
sys.setrecursionlimit(10 ** 9)
inf = sys.maxsize
mod = 10 ** 9 + 7
arr = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]
k = INT()
print((arr[k - 1])) | import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd
def input(): return sys.stdin.readline().strip()
def STR(): return eval(input())
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def S_MAP(): return list(map(str, input().split()))
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
sys.setrecursionlimit(10 ** 9)
inf = sys.maxsize
mod = 10 ** 9 + 7
arr = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]
n = INT()
print((arr[n - 1])) | 22 | 22 | 881 | 881 | import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd
def input():
return sys.stdin.readline().strip()
def STR():
return eval(input())
def INT():
return int(eval(input()))
def MAP():
return list(map(int, input().split()))
def S_MAP():
return list(map(str, input().split()))
def LIST():
return list(map(int, input().split()))
def S_LIST():
return list(map(str, input().split()))
sys.setrecursionlimit(10**9)
inf = sys.maxsize
mod = 10**9 + 7
arr = [
1,
1,
1,
2,
1,
2,
1,
5,
2,
2,
1,
5,
1,
2,
1,
14,
1,
5,
1,
5,
2,
2,
1,
15,
2,
2,
5,
4,
1,
4,
1,
51,
]
k = INT()
print((arr[k - 1]))
| import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd
def input():
return sys.stdin.readline().strip()
def STR():
return eval(input())
def INT():
return int(eval(input()))
def MAP():
return list(map(int, input().split()))
def S_MAP():
return list(map(str, input().split()))
def LIST():
return list(map(int, input().split()))
def S_LIST():
return list(map(str, input().split()))
sys.setrecursionlimit(10**9)
inf = sys.maxsize
mod = 10**9 + 7
arr = [
1,
1,
1,
2,
1,
2,
1,
5,
2,
2,
1,
5,
1,
2,
1,
14,
1,
5,
1,
5,
2,
2,
1,
15,
2,
2,
5,
4,
1,
4,
1,
51,
]
n = INT()
print((arr[n - 1]))
| false | 0 | [
"-k = INT()",
"-print((arr[k - 1]))",
"+n = INT()",
"+print((arr[n - 1]))"
]
| false | 0.128261 | 0.035932 | 3.569588 | [
"s080817580",
"s371346511"
]
|
u127499732 | p03162 | python | s020072103 | s768187615 | 217 | 154 | 37,128 | 35,636 | Accepted | Accepted | 29.03 | def main():
n, *abc = list(map(int, open(0).read().split()))
dp = [[0, 0, 0] for _ in range(n + 1)]
for i, (a, b, c) in enumerate(zip(abc[::3], abc[1::3], abc[2::3]), 1):
x, y, z = dp[i - 1]
dp[i] = [a + max(y, z), b + max(z, x), c + max(x, y)]
ans = max(dp[-1])
print(ans)
if __name__ == '__main__':
main()
| def main():
n, *abc = list(map(int, open(0).read().split()))
x, y, z = 0, 0, 0
for i, (a, b, c) in enumerate(zip(*[iter(abc)] * 3), 1):
x, y, z = a + max(y, z), b + max(z, x), c + max(x, y)
ans = max([x, y, z])
print(ans)
if __name__ == '__main__':
main()
| 13 | 12 | 357 | 300 | def main():
n, *abc = list(map(int, open(0).read().split()))
dp = [[0, 0, 0] for _ in range(n + 1)]
for i, (a, b, c) in enumerate(zip(abc[::3], abc[1::3], abc[2::3]), 1):
x, y, z = dp[i - 1]
dp[i] = [a + max(y, z), b + max(z, x), c + max(x, y)]
ans = max(dp[-1])
print(ans)
if __name__ == "__main__":
main()
| def main():
n, *abc = list(map(int, open(0).read().split()))
x, y, z = 0, 0, 0
for i, (a, b, c) in enumerate(zip(*[iter(abc)] * 3), 1):
x, y, z = a + max(y, z), b + max(z, x), c + max(x, y)
ans = max([x, y, z])
print(ans)
if __name__ == "__main__":
main()
| false | 7.692308 | [
"- dp = [[0, 0, 0] for _ in range(n + 1)]",
"- for i, (a, b, c) in enumerate(zip(abc[::3], abc[1::3], abc[2::3]), 1):",
"- x, y, z = dp[i - 1]",
"- dp[i] = [a + max(y, z), b + max(z, x), c + max(x, y)]",
"- ans = max(dp[-1])",
"+ x, y, z = 0, 0, 0",
"+ for i, (a, b, c) in enumerate(zip(*[iter(abc)] * 3), 1):",
"+ x, y, z = a + max(y, z), b + max(z, x), c + max(x, y)",
"+ ans = max([x, y, z])"
]
| false | 0.087276 | 0.054179 | 1.610866 | [
"s020072103",
"s768187615"
]
|
u724687935 | p03380 | python | s572726079 | s412260069 | 234 | 124 | 62,704 | 20,068 | Accepted | Accepted | 47.01 | N = int(eval(input()))
A = list(map(int, input().split()))
A.sort()
n = A[-1]
m = n / 2
r = 0
for i in range(N - 1):
if abs(m - A[i]) < abs(m - r):
r = A[i]
print((n, r))
| def check(n, m):
l = n // 2
r = l + (n % 2 == 1)
return min(abs(l - m), abs(r - m))
N = int(eval(input()))
A = list(map(int, input().split()))
A.sort()
n = A[-1]
pd = float('inf')
for i in range(N - 1):
a = A[i]
d = check(n, a)
if d < pd:
b = a
pd = d
print((n, b))
| 13 | 20 | 190 | 321 | N = int(eval(input()))
A = list(map(int, input().split()))
A.sort()
n = A[-1]
m = n / 2
r = 0
for i in range(N - 1):
if abs(m - A[i]) < abs(m - r):
r = A[i]
print((n, r))
| def check(n, m):
l = n // 2
r = l + (n % 2 == 1)
return min(abs(l - m), abs(r - m))
N = int(eval(input()))
A = list(map(int, input().split()))
A.sort()
n = A[-1]
pd = float("inf")
for i in range(N - 1):
a = A[i]
d = check(n, a)
if d < pd:
b = a
pd = d
print((n, b))
| false | 35 | [
"+def check(n, m):",
"+ l = n // 2",
"+ r = l + (n % 2 == 1)",
"+ return min(abs(l - m), abs(r - m))",
"+",
"+",
"-m = n / 2",
"-r = 0",
"+pd = float(\"inf\")",
"- if abs(m - A[i]) < abs(m - r):",
"- r = A[i]",
"-print((n, r))",
"+ a = A[i]",
"+ d = check(n, a)",
"+ if d < pd:",
"+ b = a",
"+ pd = d",
"+print((n, b))"
]
| false | 0.037383 | 0.037519 | 0.996372 | [
"s572726079",
"s412260069"
]
|
u945181840 | p02796 | python | s028430915 | s184565646 | 193 | 176 | 26,844 | 27,100 | Accepted | Accepted | 8.81 | import sys
from operator import itemgetter
read = sys.stdin.read
N, *XL = list(map(int, read().split()))
seq = []
for X, L in zip(*[iter(XL)] * 2):
seq.append((X - L, X + L))
seq.sort(key=itemgetter(1))
answer = 0
left = -10 ** 10
for i, j in seq:
if left <= i:
answer += 1
left = j
print(answer) | import sys
from operator import itemgetter
read = sys.stdin.read
N, *XL = list(map(int, read().split()))
seq = [(X - L, X + L) for X, L in zip(*[iter(XL)] * 2)]
seq.sort(key=itemgetter(1))
answer = 0
left = -10 ** 10
for i, j in seq:
if left <= i:
answer += 1
left = j
print(answer)
| 20 | 17 | 338 | 317 | import sys
from operator import itemgetter
read = sys.stdin.read
N, *XL = list(map(int, read().split()))
seq = []
for X, L in zip(*[iter(XL)] * 2):
seq.append((X - L, X + L))
seq.sort(key=itemgetter(1))
answer = 0
left = -(10**10)
for i, j in seq:
if left <= i:
answer += 1
left = j
print(answer)
| import sys
from operator import itemgetter
read = sys.stdin.read
N, *XL = list(map(int, read().split()))
seq = [(X - L, X + L) for X, L in zip(*[iter(XL)] * 2)]
seq.sort(key=itemgetter(1))
answer = 0
left = -(10**10)
for i, j in seq:
if left <= i:
answer += 1
left = j
print(answer)
| false | 15 | [
"-seq = []",
"-for X, L in zip(*[iter(XL)] * 2):",
"- seq.append((X - L, X + L))",
"+seq = [(X - L, X + L) for X, L in zip(*[iter(XL)] * 2)]"
]
| false | 0.0455 | 0.046568 | 0.977054 | [
"s028430915",
"s184565646"
]
|
u625729943 | p02576 | python | s518111242 | s184935852 | 91 | 67 | 65,260 | 65,368 | Accepted | Accepted | 26.37 | # import numpy as np
import sys, math
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial, gcd
from bisect import bisect_left, bisect_right
sys.setrecursionlimit(10 ** 7)
enu = enumerate
MOD = 10 ** 9 + 7
input = lambda: sys.stdin.readline()[:-1]
pl = lambda x: print(*x, sep="\n")
N, X, T = map(int, input().split())
val = N // X
if N % X == 0:
print(val * T)
else:
print((val + 1) * T)
| # import numpy as np
import sys, math
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial, gcd
from bisect import bisect_left, bisect_right
sys.setrecursionlimit(10 ** 7)
enu = enumerate
MOD = 10 ** 9 + 7
input = lambda: sys.stdin.readline()[:-1]
pl = lambda x: print(*x, sep="\n")
N, X, T = map(int, input().split())
val = (N + X - 1) // X
print(val * T)
| 20 | 17 | 494 | 451 | # import numpy as np
import sys, math
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial, gcd
from bisect import bisect_left, bisect_right
sys.setrecursionlimit(10**7)
enu = enumerate
MOD = 10**9 + 7
input = lambda: sys.stdin.readline()[:-1]
pl = lambda x: print(*x, sep="\n")
N, X, T = map(int, input().split())
val = N // X
if N % X == 0:
print(val * T)
else:
print((val + 1) * T)
| # import numpy as np
import sys, math
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial, gcd
from bisect import bisect_left, bisect_right
sys.setrecursionlimit(10**7)
enu = enumerate
MOD = 10**9 + 7
input = lambda: sys.stdin.readline()[:-1]
pl = lambda x: print(*x, sep="\n")
N, X, T = map(int, input().split())
val = (N + X - 1) // X
print(val * T)
| false | 15 | [
"-val = N // X",
"-if N % X == 0:",
"- print(val * T)",
"-else:",
"- print((val + 1) * T)",
"+val = (N + X - 1) // X",
"+print(val * T)"
]
| false | 0.036376 | 0.057579 | 0.631754 | [
"s518111242",
"s184935852"
]
|
u724963150 | p00481 | python | s075109426 | s394807300 | 31,680 | 12,020 | 38,660 | 37,748 | Accepted | Accepted | 62.06 | import queue
class unko(Exception):pass
INF=1145141919
dx=[1,-1,0,0]
dy=[0,0,1,-1]
def search(cor_s,dst):
mem=[[INF for i in range(a[1])]for j in range(a[0])]
q=queue.Queue()
q.put(cor_s)
mem[cor_s[0]][cor_s[1]]=0
while not q.empty():
cor=q.get()
for i in range(4):
x=cor[0]+dx[i]
y=cor[1]+dy[i]
if 0<=x<a[0] and 0<=y<a[1] and s[x][y]!='X' and mem[x][y]==INF:
mem[x][y]=mem[cor[0]][cor[1]]+1
if s[x][y]==str(dst):return [[x,y],mem[x][y]]
else:q.put([x,y])
#
a=[int(num)for num in input().split(' ')]
s=[list(eval(input())) for i in range(a[0])]
pos_s=[]
time=0
for li in s:
if 'S' in li:pos_s=[s.index(li),li.index('S')]
for i in range(a[2]):
ret_l=search(pos_s,i+1)
pos_s=ret_l[0]
time+=ret_l[1]
print(time) | #import queue #queue
INF=1145141919
dx=[1,-1,0,0]
dy=[0,0,1,-1]
def search(cor_s,dst):
mem=[[INF for i in range(a[1])]for j in range(a[0])]
#q=queue.Queue() #queue
#q.put(cor_s) #queue
li=[cor_s] #list
mem[cor_s[0]][cor_s[1]]=0
#while not q.empty(): #queue
while len(li)!=0: #list
#cor=q.get() #queue
cor=li.pop(0) #list
for i in range(4):
x=cor[0]+dx[i]
y=cor[1]+dy[i]
if 0<=x<a[0] and 0<=y<a[1] and s[x][y]!='X' and mem[x][y]==INF:
mem[x][y]=mem[cor[0]][cor[1]]+1
if s[x][y]==str(dst):return [[x,y],mem[x][y]]
else:
#q.put([x,y]) #queue
li.append([x,y])
#
a=[int(num)for num in input().split(' ')]
s=[list(eval(input())) for i in range(a[0])]
pos_s=[]
time=0
for li in s:
if 'S' in li:pos_s=[s.index(li),li.index('S')]
for i in range(a[2]):
ret_l=search(pos_s,i+1)
pos_s=ret_l[0]
time+=ret_l[1]
print(time) | 31 | 35 | 868 | 1,028 | import queue
class unko(Exception):
pass
INF = 1145141919
dx = [1, -1, 0, 0]
dy = [0, 0, 1, -1]
def search(cor_s, dst):
mem = [[INF for i in range(a[1])] for j in range(a[0])]
q = queue.Queue()
q.put(cor_s)
mem[cor_s[0]][cor_s[1]] = 0
while not q.empty():
cor = q.get()
for i in range(4):
x = cor[0] + dx[i]
y = cor[1] + dy[i]
if 0 <= x < a[0] and 0 <= y < a[1] and s[x][y] != "X" and mem[x][y] == INF:
mem[x][y] = mem[cor[0]][cor[1]] + 1
if s[x][y] == str(dst):
return [[x, y], mem[x][y]]
else:
q.put([x, y])
#
a = [int(num) for num in input().split(" ")]
s = [list(eval(input())) for i in range(a[0])]
pos_s = []
time = 0
for li in s:
if "S" in li:
pos_s = [s.index(li), li.index("S")]
for i in range(a[2]):
ret_l = search(pos_s, i + 1)
pos_s = ret_l[0]
time += ret_l[1]
print(time)
| # import queue #queue
INF = 1145141919
dx = [1, -1, 0, 0]
dy = [0, 0, 1, -1]
def search(cor_s, dst):
mem = [[INF for i in range(a[1])] for j in range(a[0])]
# q=queue.Queue() #queue
# q.put(cor_s) #queue
li = [cor_s] # list
mem[cor_s[0]][cor_s[1]] = 0
# while not q.empty(): #queue
while len(li) != 0: # list
# cor=q.get() #queue
cor = li.pop(0) # list
for i in range(4):
x = cor[0] + dx[i]
y = cor[1] + dy[i]
if 0 <= x < a[0] and 0 <= y < a[1] and s[x][y] != "X" and mem[x][y] == INF:
mem[x][y] = mem[cor[0]][cor[1]] + 1
if s[x][y] == str(dst):
return [[x, y], mem[x][y]]
else:
# q.put([x,y]) #queue
li.append([x, y])
#
a = [int(num) for num in input().split(" ")]
s = [list(eval(input())) for i in range(a[0])]
pos_s = []
time = 0
for li in s:
if "S" in li:
pos_s = [s.index(li), li.index("S")]
for i in range(a[2]):
ret_l = search(pos_s, i + 1)
pos_s = ret_l[0]
time += ret_l[1]
print(time)
| false | 11.428571 | [
"-import queue",
"-",
"-",
"-class unko(Exception):",
"- pass",
"-",
"-",
"+# import queue #queue",
"- q = queue.Queue()",
"- q.put(cor_s)",
"+ # q=queue.Queue() #queue",
"+ # q.put(cor_s) #queue",
"+ li = [cor_s] # list",
"- while not q.empty():",
"- cor = q.get()",
"+ # while not q.empty(): #queue",
"+ while len(li) != 0: # list",
"+ # cor=q.get() #queue",
"+ cor = li.pop(0) # list",
"- q.put([x, y])",
"+ # q.put([x,y]) #queue",
"+ li.append([x, y])"
]
| false | 0.122784 | 0.111598 | 1.100241 | [
"s075109426",
"s394807300"
]
|
u440566786 | p03013 | python | s998510322 | s929829030 | 240 | 94 | 46,404 | 81,992 | Accepted | Accepted | 60.83 | import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=sys.stdin.readline
def resolve():
n,m=list(map(int,input().split()))
fib=[0,1]
a,b=0,1
for _ in range(n):
a,b=b,(a+b)%MOD
fib.append(b)
A=[-1]+[int(eval(input())) for _ in range(m)]+[n+1]
ans=1
for i in range(m+1):
ans*=fib[A[i+1]-A[i]-1]%MOD
print((ans%MOD))
resolve() | import sys
INF = 1 << 60
MOD = 10**9 + 7 # 998244353
sys.setrecursionlimit(2147483647)
input = lambda:sys.stdin.readline().rstrip()
def resolve():
n, m = list(map(int, input().split()))
S = set(int(eval(input())) for _ in range(m))
a, b = 0, 1 # a[-1], a[0]
for i in range(1, n + 1):
if i in S:
a, b = b, 0
else:
a, b = b, (a + b) % MOD
print(b)
resolve() | 19 | 18 | 410 | 422 | import sys
sys.setrecursionlimit(2147483647)
INF = float("inf")
MOD = 10**9 + 7
input = sys.stdin.readline
def resolve():
n, m = list(map(int, input().split()))
fib = [0, 1]
a, b = 0, 1
for _ in range(n):
a, b = b, (a + b) % MOD
fib.append(b)
A = [-1] + [int(eval(input())) for _ in range(m)] + [n + 1]
ans = 1
for i in range(m + 1):
ans *= fib[A[i + 1] - A[i] - 1] % MOD
print((ans % MOD))
resolve()
| import sys
INF = 1 << 60
MOD = 10**9 + 7 # 998244353
sys.setrecursionlimit(2147483647)
input = lambda: sys.stdin.readline().rstrip()
def resolve():
n, m = list(map(int, input().split()))
S = set(int(eval(input())) for _ in range(m))
a, b = 0, 1 # a[-1], a[0]
for i in range(1, n + 1):
if i in S:
a, b = b, 0
else:
a, b = b, (a + b) % MOD
print(b)
resolve()
| false | 5.263158 | [
"+INF = 1 << 60",
"+MOD = 10**9 + 7 # 998244353",
"-INF = float(\"inf\")",
"-MOD = 10**9 + 7",
"-input = sys.stdin.readline",
"+input = lambda: sys.stdin.readline().rstrip()",
"- fib = [0, 1]",
"- a, b = 0, 1",
"- for _ in range(n):",
"- a, b = b, (a + b) % MOD",
"- fib.append(b)",
"- A = [-1] + [int(eval(input())) for _ in range(m)] + [n + 1]",
"- ans = 1",
"- for i in range(m + 1):",
"- ans *= fib[A[i + 1] - A[i] - 1] % MOD",
"- print((ans % MOD))",
"+ S = set(int(eval(input())) for _ in range(m))",
"+ a, b = 0, 1 # a[-1], a[0]",
"+ for i in range(1, n + 1):",
"+ if i in S:",
"+ a, b = b, 0",
"+ else:",
"+ a, b = b, (a + b) % MOD",
"+ print(b)"
]
| false | 0.034652 | 0.075047 | 0.461732 | [
"s998510322",
"s929829030"
]
|
u690419532 | p02622 | python | s253414927 | s248006741 | 72 | 62 | 12,504 | 9,404 | Accepted | Accepted | 13.89 | S = list(str(eval(input())))
T = list(str(eval(input())))
count = 0
for i in range(len(S)):
if S[i] != T[i]:
count += 1
print(count) | S = str(eval(input()))
T = str(eval(input()))
count = 0
for i in range(len(S)):
if S[i] != T[i]:
count +=1
print(count) | 8 | 8 | 140 | 127 | S = list(str(eval(input())))
T = list(str(eval(input())))
count = 0
for i in range(len(S)):
if S[i] != T[i]:
count += 1
print(count)
| S = str(eval(input()))
T = str(eval(input()))
count = 0
for i in range(len(S)):
if S[i] != T[i]:
count += 1
print(count)
| false | 0 | [
"-S = list(str(eval(input())))",
"-T = list(str(eval(input())))",
"+S = str(eval(input()))",
"+T = str(eval(input()))"
]
| false | 0.046705 | 0.037009 | 1.262002 | [
"s253414927",
"s248006741"
]
|
u678167152 | p02541 | python | s088896586 | s194222149 | 1,274 | 417 | 68,680 | 68,812 | Accepted | Accepted | 67.27 | #素因数分解、計算量はO(√N)
from collections import defaultdict
def factorize(n):
b = 2
dic = defaultdict(lambda: 0)
while b * b <= n:
while n % b == 0:
n //= b
dic[b] += 1
b = b + 1
if n > 1:
dic[n] += 1
return dic
N = int(eval(input()))
fct = factorize(2*N)
lis = []
for k,v in list(fct.items()):
lis.append(pow(k,v))
ans = 10**18
from itertools import groupby, accumulate, product, permutations, combinations
for pro in product([0,1],repeat=len(lis)):
prod1 = 1
for i,p in enumerate(pro):
if p==1:
prod1 *= lis[i]
if prod1==1:
continue
prod2 = (N*2)//prod1
if prod1<prod2:
continue
for i in range(1,prod2+1):
if prod1*i>ans:
break
if (prod1*i-1)%prod2==0:
ans = min(ans, prod1*i-1)
break
if (prod1*i+1)%prod2==0:
ans = min(ans, prod1*i)
break
print(ans)
| #素因数分解、計算量はO(√N)
from collections import defaultdict
def factorize(n):
b = 2
dic = defaultdict(lambda: 0)
while b * b <= n:
while n % b == 0:
n //= b
dic[b] += 1
b = b + 1
if n > 1:
dic[n] += 1
return dic
N = int(eval(input()))
fct = factorize(2*N)
lis = []
for k,v in list(fct.items()):
lis.append(pow(k,v))
lis.sort(reverse=True)
ans = 10**18
from itertools import groupby, accumulate, product, permutations, combinations
for pro in product([1,0],repeat=len(lis)):
prod1 = 1
for i,p in enumerate(pro):
if p==1:
prod1 *= lis[i]
prod2 = (N*2)//prod1
if prod1<prod2:
# prod1,prod2 = prod2,prod1
continue
for i in range(1,prod2+1):
if prod1*i>ans:
break
if (prod1*i-1)%prod2==0:
ans = min(ans, prod1*i-1)
break
if (prod1*i+1)%prod2==0:
ans = min(ans, prod1*i)
break
print(ans)
| 43 | 41 | 889 | 910 | # 素因数分解、計算量はO(√N)
from collections import defaultdict
def factorize(n):
b = 2
dic = defaultdict(lambda: 0)
while b * b <= n:
while n % b == 0:
n //= b
dic[b] += 1
b = b + 1
if n > 1:
dic[n] += 1
return dic
N = int(eval(input()))
fct = factorize(2 * N)
lis = []
for k, v in list(fct.items()):
lis.append(pow(k, v))
ans = 10**18
from itertools import groupby, accumulate, product, permutations, combinations
for pro in product([0, 1], repeat=len(lis)):
prod1 = 1
for i, p in enumerate(pro):
if p == 1:
prod1 *= lis[i]
if prod1 == 1:
continue
prod2 = (N * 2) // prod1
if prod1 < prod2:
continue
for i in range(1, prod2 + 1):
if prod1 * i > ans:
break
if (prod1 * i - 1) % prod2 == 0:
ans = min(ans, prod1 * i - 1)
break
if (prod1 * i + 1) % prod2 == 0:
ans = min(ans, prod1 * i)
break
print(ans)
| # 素因数分解、計算量はO(√N)
from collections import defaultdict
def factorize(n):
b = 2
dic = defaultdict(lambda: 0)
while b * b <= n:
while n % b == 0:
n //= b
dic[b] += 1
b = b + 1
if n > 1:
dic[n] += 1
return dic
N = int(eval(input()))
fct = factorize(2 * N)
lis = []
for k, v in list(fct.items()):
lis.append(pow(k, v))
lis.sort(reverse=True)
ans = 10**18
from itertools import groupby, accumulate, product, permutations, combinations
for pro in product([1, 0], repeat=len(lis)):
prod1 = 1
for i, p in enumerate(pro):
if p == 1:
prod1 *= lis[i]
prod2 = (N * 2) // prod1
if prod1 < prod2:
# prod1,prod2 = prod2,prod1
continue
for i in range(1, prod2 + 1):
if prod1 * i > ans:
break
if (prod1 * i - 1) % prod2 == 0:
ans = min(ans, prod1 * i - 1)
break
if (prod1 * i + 1) % prod2 == 0:
ans = min(ans, prod1 * i)
break
print(ans)
| false | 4.651163 | [
"+lis.sort(reverse=True)",
"-for pro in product([0, 1], repeat=len(lis)):",
"+for pro in product([1, 0], repeat=len(lis)):",
"- if prod1 == 1:",
"- continue",
"+ # prod1,prod2 = prod2,prod1"
]
| false | 0.040291 | 0.079415 | 0.507351 | [
"s088896586",
"s194222149"
]
|
u761320129 | p03449 | python | s510009985 | s498958242 | 19 | 17 | 3,060 | 3,060 | Accepted | Accepted | 10.53 | N = int(eval(input()))
A = list(map(int,input().split()))
B = list(map(int,input().split()))
ans = 0
for i in range(N):
tmp = sum(A[:i+1]) + sum(B[i:])
ans = max(ans, tmp)
print(ans) | N = int(eval(input()))
A = list(map(int,input().split()))
B = list(map(int,input().split()))
ans = 0
for i in range(N):
ans = max(ans, sum(A[:i+1]) + sum(B[i:]))
print(ans) | 8 | 8 | 191 | 178 | N = int(eval(input()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
ans = 0
for i in range(N):
tmp = sum(A[: i + 1]) + sum(B[i:])
ans = max(ans, tmp)
print(ans)
| N = int(eval(input()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
ans = 0
for i in range(N):
ans = max(ans, sum(A[: i + 1]) + sum(B[i:]))
print(ans)
| false | 0 | [
"- tmp = sum(A[: i + 1]) + sum(B[i:])",
"- ans = max(ans, tmp)",
"+ ans = max(ans, sum(A[: i + 1]) + sum(B[i:]))"
]
| false | 0.045438 | 0.074019 | 0.613868 | [
"s510009985",
"s498958242"
]
|
u579324544 | p02922 | python | s623017298 | s758491711 | 193 | 19 | 38,384 | 3,064 | Accepted | Accepted | 90.16 | from copy import deepcopy
from math import ceil
if __name__ == "__main__":
a = list(map(int, input().split()))
n = deepcopy(a[0])
i = 1
if a[0] == a[1]: print(i)
elif a[1] == 1: print((0))
elif a[0] >= a[1]: print(i)
else:
while True:
i += 1
n += a[0] - 1
if n >= a[1]:
print(i)
break | #n = input()
a = list(map(int, input().split()))
#b = list(map(int, input().split()))
#c = list(map(int, input().split()))
r = 1
c = 0
if a[1] == 1:
print((0))
elif a[0] == a[1]:
print((1))
else:
while r < a[1]:
c += 1
r -= 1
r += a[0]
print(c) | 17 | 16 | 403 | 295 | from copy import deepcopy
from math import ceil
if __name__ == "__main__":
a = list(map(int, input().split()))
n = deepcopy(a[0])
i = 1
if a[0] == a[1]:
print(i)
elif a[1] == 1:
print((0))
elif a[0] >= a[1]:
print(i)
else:
while True:
i += 1
n += a[0] - 1
if n >= a[1]:
print(i)
break
| # n = input()
a = list(map(int, input().split()))
# b = list(map(int, input().split()))
# c = list(map(int, input().split()))
r = 1
c = 0
if a[1] == 1:
print((0))
elif a[0] == a[1]:
print((1))
else:
while r < a[1]:
c += 1
r -= 1
r += a[0]
print(c)
| false | 5.882353 | [
"-from copy import deepcopy",
"-from math import ceil",
"-",
"-if __name__ == \"__main__\":",
"- a = list(map(int, input().split()))",
"- n = deepcopy(a[0])",
"- i = 1",
"- if a[0] == a[1]:",
"- print(i)",
"- elif a[1] == 1:",
"- print((0))",
"- elif a[0] >= a[1]:",
"- print(i)",
"- else:",
"- while True:",
"- i += 1",
"- n += a[0] - 1",
"- if n >= a[1]:",
"- print(i)",
"- break",
"+# n = input()",
"+a = list(map(int, input().split()))",
"+# b = list(map(int, input().split()))",
"+# c = list(map(int, input().split()))",
"+r = 1",
"+c = 0",
"+if a[1] == 1:",
"+ print((0))",
"+elif a[0] == a[1]:",
"+ print((1))",
"+else:",
"+ while r < a[1]:",
"+ c += 1",
"+ r -= 1",
"+ r += a[0]",
"+ print(c)"
]
| false | 0.084849 | 0.040564 | 2.091729 | [
"s623017298",
"s758491711"
]
|
u332385682 | p03835 | python | s638897948 | s392984507 | 1,505 | 280 | 3,064 | 40,812 | Accepted | Accepted | 81.4 |
K, S = list(map(int, input().split()))
wariate = 0
for x in range(0, K + 1):
for y in range(0, K + 1):
z = S - (x + y)
if 0 <= z <= K:
wariate += 1
print(wariate) | K, S = list(map(int, input().split()))
cnt = 0
for x in range(K + 1):
for y in range(K + 1):
z = S - (x + y)
cnt += (0 <= z <= K)
print(cnt) | 11 | 9 | 201 | 164 | K, S = list(map(int, input().split()))
wariate = 0
for x in range(0, K + 1):
for y in range(0, K + 1):
z = S - (x + y)
if 0 <= z <= K:
wariate += 1
print(wariate)
| K, S = list(map(int, input().split()))
cnt = 0
for x in range(K + 1):
for y in range(K + 1):
z = S - (x + y)
cnt += 0 <= z <= K
print(cnt)
| false | 18.181818 | [
"-wariate = 0",
"-for x in range(0, K + 1):",
"- for y in range(0, K + 1):",
"+cnt = 0",
"+for x in range(K + 1):",
"+ for y in range(K + 1):",
"- if 0 <= z <= K:",
"- wariate += 1",
"-print(wariate)",
"+ cnt += 0 <= z <= K",
"+print(cnt)"
]
| false | 0.038682 | 0.215825 | 0.179227 | [
"s638897948",
"s392984507"
]
|
u347640436 | p02984 | python | s377737947 | s013883261 | 131 | 118 | 20,120 | 14,032 | Accepted | Accepted | 9.92 | N = int(eval(input()))
A = list(map(int, input().split()))
t = [0] * N
t[0] = sum(A[::2]) - sum(A[1::2])
for i in range(1, N):
t[i] = 2 * A[i - 1] - t[i - 1]
print((*list(map(str, t))))
| N = int(eval(input()))
A = list(map(int, input().split()))
result = [0] * N
result[0] = sum(A[::2]) - sum(A[1::2])
for i in range(1, N):
result[i] = 2 * A[i - 1] - result[i - 1]
print((*result))
| 8 | 8 | 190 | 199 | N = int(eval(input()))
A = list(map(int, input().split()))
t = [0] * N
t[0] = sum(A[::2]) - sum(A[1::2])
for i in range(1, N):
t[i] = 2 * A[i - 1] - t[i - 1]
print((*list(map(str, t))))
| N = int(eval(input()))
A = list(map(int, input().split()))
result = [0] * N
result[0] = sum(A[::2]) - sum(A[1::2])
for i in range(1, N):
result[i] = 2 * A[i - 1] - result[i - 1]
print((*result))
| false | 0 | [
"-t = [0] * N",
"-t[0] = sum(A[::2]) - sum(A[1::2])",
"+result = [0] * N",
"+result[0] = sum(A[::2]) - sum(A[1::2])",
"- t[i] = 2 * A[i - 1] - t[i - 1]",
"-print((*list(map(str, t))))",
"+ result[i] = 2 * A[i - 1] - result[i - 1]",
"+print((*result))"
]
| false | 0.04613 | 0.0453 | 1.018327 | [
"s377737947",
"s013883261"
]
|
u729133443 | p03074 | python | s988660712 | s532479642 | 196 | 88 | 54,480 | 9,388 | Accepted | Accepted | 55.1 | n,k=list(map(int,input().split()))
*s,=eval(input())
g=[]
t=1
for i in range(1,n):
if s[i]==s[i-1]:
t+=1
else:
g.append(t)
t=1
g.append(t)
for i in range(1,len(g)):
g[i]+=g[i-1]
g=[0]+g+[g[-1]]
a=0
for i in range(s[0]=='1',len(g),2):
a=max(a,g[i]-g[max(0,i-2*k-1)])
print(a) | n,k=list(map(int,input().split()))
*s,=eval(input())
g=[]
t=1
for i in range(1,n):
if s[i]==s[i-1]:t+=1
else:g.append(t);t=1
g.append(t)
for i in range(1,len(g)):g[i]+=g[i-1]
g=[0]+g+[g[-1]]
print((max(g[i]-g[max(0,i-2*k-1)]for i in range(s[0]=='1',len(g),2)))) | 18 | 11 | 319 | 259 | n, k = list(map(int, input().split()))
(*s,) = eval(input())
g = []
t = 1
for i in range(1, n):
if s[i] == s[i - 1]:
t += 1
else:
g.append(t)
t = 1
g.append(t)
for i in range(1, len(g)):
g[i] += g[i - 1]
g = [0] + g + [g[-1]]
a = 0
for i in range(s[0] == "1", len(g), 2):
a = max(a, g[i] - g[max(0, i - 2 * k - 1)])
print(a)
| n, k = list(map(int, input().split()))
(*s,) = eval(input())
g = []
t = 1
for i in range(1, n):
if s[i] == s[i - 1]:
t += 1
else:
g.append(t)
t = 1
g.append(t)
for i in range(1, len(g)):
g[i] += g[i - 1]
g = [0] + g + [g[-1]]
print((max(g[i] - g[max(0, i - 2 * k - 1)] for i in range(s[0] == "1", len(g), 2))))
| false | 38.888889 | [
"-a = 0",
"-for i in range(s[0] == \"1\", len(g), 2):",
"- a = max(a, g[i] - g[max(0, i - 2 * k - 1)])",
"-print(a)",
"+print((max(g[i] - g[max(0, i - 2 * k - 1)] for i in range(s[0] == \"1\", len(g), 2))))"
]
| false | 0.041342 | 0.041018 | 1.007896 | [
"s988660712",
"s532479642"
]
|
u133936772 | p02850 | python | s707729497 | s645845555 | 742 | 466 | 46,360 | 94,520 | Accepted | Accepted | 37.2 | import sys
n=int(eval(input()))
g=[[] for _ in range(n)]
for i in range(n-1):
a,b=list(map(int,sys.stdin.readline().split()))
g[a-1].append([b-1,i])
g[b-1].append([a-1,i])
print((max(len(v) for v in g)))
from collections import deque
l=[0]*(n-1)
q=deque([0])
b=[1]+[0]*(n-1)
while q:
v=q.pop()
c=-1
k=1
for u,e in g[v]:
if b[u]: c=l[e]
for u,e in g[v]:
if b[u]: continue
if k==c: k+=1
l[e]=k
k+=1
q.appendleft(u)
b[u]=1
for c in l: print(c) | import sys
sys.setrecursionlimit(10**6)
n=int(eval(input()))
g=[[] for _ in range(n)]
for i in range(n-1):
a,b=list(map(int,input().split()))
g[a-1]+=[(b-1,i)]
g[b-1]+=[(a-1,i)]
l=[0]*(n-1)
def dfs(v,p=-1,s=-1):
t=1
for c,i in g[v]:
if c==p: continue
if t==s: t+=1
l[i]=t
dfs(c,v,t)
t+=1
dfs(0)
print((max(l)))
for i in l: print(i) | 26 | 20 | 495 | 366 | import sys
n = int(eval(input()))
g = [[] for _ in range(n)]
for i in range(n - 1):
a, b = list(map(int, sys.stdin.readline().split()))
g[a - 1].append([b - 1, i])
g[b - 1].append([a - 1, i])
print((max(len(v) for v in g)))
from collections import deque
l = [0] * (n - 1)
q = deque([0])
b = [1] + [0] * (n - 1)
while q:
v = q.pop()
c = -1
k = 1
for u, e in g[v]:
if b[u]:
c = l[e]
for u, e in g[v]:
if b[u]:
continue
if k == c:
k += 1
l[e] = k
k += 1
q.appendleft(u)
b[u] = 1
for c in l:
print(c)
| import sys
sys.setrecursionlimit(10**6)
n = int(eval(input()))
g = [[] for _ in range(n)]
for i in range(n - 1):
a, b = list(map(int, input().split()))
g[a - 1] += [(b - 1, i)]
g[b - 1] += [(a - 1, i)]
l = [0] * (n - 1)
def dfs(v, p=-1, s=-1):
t = 1
for c, i in g[v]:
if c == p:
continue
if t == s:
t += 1
l[i] = t
dfs(c, v, t)
t += 1
dfs(0)
print((max(l)))
for i in l:
print(i)
| false | 23.076923 | [
"+sys.setrecursionlimit(10**6)",
"- a, b = list(map(int, sys.stdin.readline().split()))",
"- g[a - 1].append([b - 1, i])",
"- g[b - 1].append([a - 1, i])",
"-print((max(len(v) for v in g)))",
"-from collections import deque",
"+ a, b = list(map(int, input().split()))",
"+ g[a - 1] += [(b - 1, i)]",
"+ g[b - 1] += [(a - 1, i)]",
"+l = [0] * (n - 1)",
"-l = [0] * (n - 1)",
"-q = deque([0])",
"-b = [1] + [0] * (n - 1)",
"-while q:",
"- v = q.pop()",
"- c = -1",
"- k = 1",
"- for u, e in g[v]:",
"- if b[u]:",
"- c = l[e]",
"- for u, e in g[v]:",
"- if b[u]:",
"+",
"+def dfs(v, p=-1, s=-1):",
"+ t = 1",
"+ for c, i in g[v]:",
"+ if c == p:",
"- if k == c:",
"- k += 1",
"- l[e] = k",
"- k += 1",
"- q.appendleft(u)",
"- b[u] = 1",
"-for c in l:",
"- print(c)",
"+ if t == s:",
"+ t += 1",
"+ l[i] = t",
"+ dfs(c, v, t)",
"+ t += 1",
"+",
"+",
"+dfs(0)",
"+print((max(l)))",
"+for i in l:",
"+ print(i)"
]
| false | 0.069622 | 0.085611 | 0.813238 | [
"s707729497",
"s645845555"
]
|
u815763296 | p02631 | python | s243081838 | s841816825 | 228 | 175 | 31,440 | 31,396 | Accepted | Accepted | 23.25 | N = int(input())
total = 0
i = 0
alist = []
for a in input().split():
alist.append(int(a))
total = total ^ int(a)
i = i+1
for j in range(N):
ans = total ^ alist[j]
print(ans, end=" ")
| N = int(input())
A = list(map(int, input().split()))
total = A[0]
for i in range(1, N):
total ^= A[i]
for i in range(N):
print(total ^ A[i], end=" ")
| 12 | 7 | 216 | 164 | N = int(input())
total = 0
i = 0
alist = []
for a in input().split():
alist.append(int(a))
total = total ^ int(a)
i = i + 1
for j in range(N):
ans = total ^ alist[j]
print(ans, end=" ")
| N = int(input())
A = list(map(int, input().split()))
total = A[0]
for i in range(1, N):
total ^= A[i]
for i in range(N):
print(total ^ A[i], end=" ")
| false | 41.666667 | [
"-total = 0",
"-i = 0",
"-alist = []",
"-for a in input().split():",
"- alist.append(int(a))",
"- total = total ^ int(a)",
"- i = i + 1",
"-for j in range(N):",
"- ans = total ^ alist[j]",
"- print(ans, end=\" \")",
"+A = list(map(int, input().split()))",
"+total = A[0]",
"+for i in range(1, N):",
"+ total ^= A[i]",
"+for i in range(N):",
"+ print(total ^ A[i], end=\" \")"
]
| false | 0.044072 | 0.04268 | 1.032614 | [
"s243081838",
"s841816825"
]
|
u633068244 | p00219 | python | s954807090 | s448258980 | 230 | 50 | 4,528 | 4,516 | Accepted | Accepted | 78.26 | while 1:
n=eval(input())
if n==0:break
h=[0]*10
for i in range(n):
h[eval(input())]+=1
for i in range(10):
print("*"*h[i] if h[i] else "-")
| while 1:
n=eval(input())
if n==0:break
h=[0]*10
for i in range(n):
h[int(input())]+=1
for i in range(10):
print("*"*h[i] if h[i] else "-") | 9 | 8 | 145 | 151 | while 1:
n = eval(input())
if n == 0:
break
h = [0] * 10
for i in range(n):
h[eval(input())] += 1
for i in range(10):
print("*" * h[i] if h[i] else "-")
| while 1:
n = eval(input())
if n == 0:
break
h = [0] * 10
for i in range(n):
h[int(input())] += 1
for i in range(10):
print("*" * h[i] if h[i] else "-")
| false | 11.111111 | [
"- h[eval(input())] += 1",
"+ h[int(input())] += 1"
]
| false | 0.045792 | 0.08435 | 0.542885 | [
"s954807090",
"s448258980"
]
|
u970269944 | p00462 | python | s191678434 | s404941002 | 4,690 | 290 | 21,032 | 13,340 | Accepted | Accepted | 93.82 | def print_sum():
d = int(input())
if d == 0: return False
n, m = int(input()), int(input())
S = [int(input()) for _ in range(n-1)]
K = sorted([int(input()) for _ in range(m)], reverse=True)
S = sorted(S) + [d]
S_k = [[] for _ in range(len(S))]
for i, s in enumerate(S):
for j in range(len(K)-1, -1, -1):
if K[j] <= s:
S_k[i].append(K.pop())
else:
break
sum = 0
S = [0] + S
for i, sk in enumerate(S_k):
for k in sk:
sum += min(k-S[i], S[i+1]-k)
print(sum)
return True
while print_sum():
pass | def find(l, e):
start, end = 0, len(l)
while True:
mid = (start+end)//2
if l[mid] == e:
return (e, e)
elif (l[mid] > e):
if (l[mid-1] < e):
return (l[mid-1], l[mid])
end = mid
continue
elif (l[mid] < e):
if (l[mid+1] > e):
return (l[mid], l[mid+1])
start = mid
def print_sum():
d = int(input())
if d == 0: return False
n, m = int(input()), int(input())
S = [int(input()) for _ in range(n-1)]
K = [int(input()) for _ in range(m)]
S = [0] + sorted(S) + [d]
sum = 0
for k in K:
low, high = find(S, k)
sum += min(k-low, high-k)
print(sum)
return True
while (print_sum()):
pass | 24 | 32 | 568 | 676 | def print_sum():
d = int(input())
if d == 0:
return False
n, m = int(input()), int(input())
S = [int(input()) for _ in range(n - 1)]
K = sorted([int(input()) for _ in range(m)], reverse=True)
S = sorted(S) + [d]
S_k = [[] for _ in range(len(S))]
for i, s in enumerate(S):
for j in range(len(K) - 1, -1, -1):
if K[j] <= s:
S_k[i].append(K.pop())
else:
break
sum = 0
S = [0] + S
for i, sk in enumerate(S_k):
for k in sk:
sum += min(k - S[i], S[i + 1] - k)
print(sum)
return True
while print_sum():
pass
| def find(l, e):
start, end = 0, len(l)
while True:
mid = (start + end) // 2
if l[mid] == e:
return (e, e)
elif l[mid] > e:
if l[mid - 1] < e:
return (l[mid - 1], l[mid])
end = mid
continue
elif l[mid] < e:
if l[mid + 1] > e:
return (l[mid], l[mid + 1])
start = mid
def print_sum():
d = int(input())
if d == 0:
return False
n, m = int(input()), int(input())
S = [int(input()) for _ in range(n - 1)]
K = [int(input()) for _ in range(m)]
S = [0] + sorted(S) + [d]
sum = 0
for k in K:
low, high = find(S, k)
sum += min(k - low, high - k)
print(sum)
return True
while print_sum():
pass
| false | 25 | [
"+def find(l, e):",
"+ start, end = 0, len(l)",
"+ while True:",
"+ mid = (start + end) // 2",
"+ if l[mid] == e:",
"+ return (e, e)",
"+ elif l[mid] > e:",
"+ if l[mid - 1] < e:",
"+ return (l[mid - 1], l[mid])",
"+ end = mid",
"+ continue",
"+ elif l[mid] < e:",
"+ if l[mid + 1] > e:",
"+ return (l[mid], l[mid + 1])",
"+ start = mid",
"+",
"+",
"- K = sorted([int(input()) for _ in range(m)], reverse=True)",
"- S = sorted(S) + [d]",
"- S_k = [[] for _ in range(len(S))]",
"- for i, s in enumerate(S):",
"- for j in range(len(K) - 1, -1, -1):",
"- if K[j] <= s:",
"- S_k[i].append(K.pop())",
"- else:",
"- break",
"+ K = [int(input()) for _ in range(m)]",
"+ S = [0] + sorted(S) + [d]",
"- S = [0] + S",
"- for i, sk in enumerate(S_k):",
"- for k in sk:",
"- sum += min(k - S[i], S[i + 1] - k)",
"+ for k in K:",
"+ low, high = find(S, k)",
"+ sum += min(k - low, high - k)"
]
| false | 0.043818 | 0.035924 | 1.219762 | [
"s191678434",
"s404941002"
]
|
u246820565 | p03610 | python | s075128886 | s002675514 | 39 | 19 | 3,572 | 4,264 | Accepted | Accepted | 51.28 | s = eval(input())
ss = []
for i in range(len(s)):
if i%2 == 0:
ss.append(s[i])
print((''.join(ss))) | s = list(eval(input()))
print((''.join(s[::2])))
| 6 | 2 | 99 | 42 | s = eval(input())
ss = []
for i in range(len(s)):
if i % 2 == 0:
ss.append(s[i])
print(("".join(ss)))
| s = list(eval(input()))
print(("".join(s[::2])))
| false | 66.666667 | [
"-s = eval(input())",
"-ss = []",
"-for i in range(len(s)):",
"- if i % 2 == 0:",
"- ss.append(s[i])",
"-print((\"\".join(ss)))",
"+s = list(eval(input()))",
"+print((\"\".join(s[::2])))"
]
| false | 0.030382 | 0.031881 | 0.952988 | [
"s075128886",
"s002675514"
]
|
u476225888 | p02579 | python | s918354939 | s691931038 | 1,433 | 1,149 | 130,748 | 112,004 | Accepted | Accepted | 19.82 | import sys, math
import io, os
#data = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
#from bisect import bisect_left as bl, bisect_right as br, insort
from heapq import heapify, heappush, heappop
#from collections import defaultdict as dd, deque, Counter
#from itertools import permutations,combinations
def data(): return sys.stdin.readline().strip()
def mdata(): return list(map(int, data().split()))
def outl(var) : sys.stdout.write(' '.join(map(str, var))+'\n')
def out(var) : sys.stdout.write(str(var)+'\n')
from decimal import Decimal
#from fractions import Fraction
#sys.setrecursionlimit(100000)
INF = float('inf')
mod = int(1e9)+7
h,w=mdata()
ch,cw=mdata()
dh,dw=mdata()
ch,cw,dh,dw=ch-1,cw-1,dh-1,dw-1
S=[data() for i in range(h)]
steps=[(0,1),(1,0),(-1,0),(0,-1)]
dist=[[INF]*w for i in range(h)]
dist[ch][cw]=0
queue = [(0, (ch, cw))]
while queue:
path_len, (u, v) = heappop(queue)
if path_len == dist[u][v]:
for i in range(-2, 3):
for j in range(-2, 3):
if 0 <= u + i < h and 0 <= v + j < w and S[u + i][v + j] == '.':
if (i,j) in steps:
if path_len < dist[u+i][v+j]:
dist[u+i][v+j] = path_len
heappush(queue, (path_len, (u+i, v+j)))
else:
if 1 + path_len < dist[u + i][v + j]:
dist[u + i][v + j] = 1 + path_len
heappush(queue, (1 + path_len, (u + i, v + j)))
if dist[dh][dw]!=INF:
out(dist[dh][dw])
else:
out(-1)
| import sys, math
import io, os
#data = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
#from bisect import bisect_left as bl, bisect_right as br, insort
#from heapq import heapify, heappush, heappop
from collections import defaultdict as dd, deque, Counter
#from itertools import permutations,combinations
def data(): return sys.stdin.readline().strip()
def mdata(): return list(map(int, data().split()))
def outl(var) : sys.stdout.write(' '.join(map(str, var))+'\n')
def out(var) : sys.stdout.write(str(var)+'\n')
from decimal import Decimal
#from fractions import Fraction
#sys.setrecursionlimit(100000)
INF = float('inf')
mod = int(1e9)+7
h,w=mdata()
ch,cw=mdata()
dh,dw=mdata()
ch,cw,dh,dw=ch-1,cw-1,dh-1,dw-1
S=[data() for i in range(h)]
steps=[(0,1),(1,0),(-1,0),(0,-1)]
dist=[[INF]*w for i in range(h)]
dist[ch][cw]=0
queue = deque()
queue.append((ch, cw))
while queue:
u, v = queue.popleft()
d=dist[u][v]
for i in range(-2, 3):
for j in range(-2, 3):
if 0 <= u + i < h and 0 <= v + j < w and S[u + i][v + j] == '.':
if (i,j) in steps:
if d < dist[u+i][v+j]:
dist[u+i][v+j] = d
queue.appendleft((u+i,v+j))
else:
if 1 + d < dist[u + i][v + j]:
dist[u + i][v + j] = 1 + d
queue.append((u + i, v + j))
if dist[dh][dw]!=INF:
out(dist[dh][dw])
else:
out(-1)
| 48 | 49 | 1,637 | 1,525 | import sys, math
import io, os
# data = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
# from bisect import bisect_left as bl, bisect_right as br, insort
from heapq import heapify, heappush, heappop
# from collections import defaultdict as dd, deque, Counter
# from itertools import permutations,combinations
def data():
return sys.stdin.readline().strip()
def mdata():
return list(map(int, data().split()))
def outl(var):
sys.stdout.write(" ".join(map(str, var)) + "\n")
def out(var):
sys.stdout.write(str(var) + "\n")
from decimal import Decimal
# from fractions import Fraction
# sys.setrecursionlimit(100000)
INF = float("inf")
mod = int(1e9) + 7
h, w = mdata()
ch, cw = mdata()
dh, dw = mdata()
ch, cw, dh, dw = ch - 1, cw - 1, dh - 1, dw - 1
S = [data() for i in range(h)]
steps = [(0, 1), (1, 0), (-1, 0), (0, -1)]
dist = [[INF] * w for i in range(h)]
dist[ch][cw] = 0
queue = [(0, (ch, cw))]
while queue:
path_len, (u, v) = heappop(queue)
if path_len == dist[u][v]:
for i in range(-2, 3):
for j in range(-2, 3):
if 0 <= u + i < h and 0 <= v + j < w and S[u + i][v + j] == ".":
if (i, j) in steps:
if path_len < dist[u + i][v + j]:
dist[u + i][v + j] = path_len
heappush(queue, (path_len, (u + i, v + j)))
else:
if 1 + path_len < dist[u + i][v + j]:
dist[u + i][v + j] = 1 + path_len
heappush(queue, (1 + path_len, (u + i, v + j)))
if dist[dh][dw] != INF:
out(dist[dh][dw])
else:
out(-1)
| import sys, math
import io, os
# data = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
# from bisect import bisect_left as bl, bisect_right as br, insort
# from heapq import heapify, heappush, heappop
from collections import defaultdict as dd, deque, Counter
# from itertools import permutations,combinations
def data():
return sys.stdin.readline().strip()
def mdata():
return list(map(int, data().split()))
def outl(var):
sys.stdout.write(" ".join(map(str, var)) + "\n")
def out(var):
sys.stdout.write(str(var) + "\n")
from decimal import Decimal
# from fractions import Fraction
# sys.setrecursionlimit(100000)
INF = float("inf")
mod = int(1e9) + 7
h, w = mdata()
ch, cw = mdata()
dh, dw = mdata()
ch, cw, dh, dw = ch - 1, cw - 1, dh - 1, dw - 1
S = [data() for i in range(h)]
steps = [(0, 1), (1, 0), (-1, 0), (0, -1)]
dist = [[INF] * w for i in range(h)]
dist[ch][cw] = 0
queue = deque()
queue.append((ch, cw))
while queue:
u, v = queue.popleft()
d = dist[u][v]
for i in range(-2, 3):
for j in range(-2, 3):
if 0 <= u + i < h and 0 <= v + j < w and S[u + i][v + j] == ".":
if (i, j) in steps:
if d < dist[u + i][v + j]:
dist[u + i][v + j] = d
queue.appendleft((u + i, v + j))
else:
if 1 + d < dist[u + i][v + j]:
dist[u + i][v + j] = 1 + d
queue.append((u + i, v + j))
if dist[dh][dw] != INF:
out(dist[dh][dw])
else:
out(-1)
| false | 2.040816 | [
"-from heapq import heapify, heappush, heappop",
"+# from heapq import heapify, heappush, heappop",
"+from collections import defaultdict as dd, deque, Counter",
"-# from collections import defaultdict as dd, deque, Counter",
"-queue = [(0, (ch, cw))]",
"+queue = deque()",
"+queue.append((ch, cw))",
"- path_len, (u, v) = heappop(queue)",
"- if path_len == dist[u][v]:",
"- for i in range(-2, 3):",
"- for j in range(-2, 3):",
"- if 0 <= u + i < h and 0 <= v + j < w and S[u + i][v + j] == \".\":",
"- if (i, j) in steps:",
"- if path_len < dist[u + i][v + j]:",
"- dist[u + i][v + j] = path_len",
"- heappush(queue, (path_len, (u + i, v + j)))",
"- else:",
"- if 1 + path_len < dist[u + i][v + j]:",
"- dist[u + i][v + j] = 1 + path_len",
"- heappush(queue, (1 + path_len, (u + i, v + j)))",
"+ u, v = queue.popleft()",
"+ d = dist[u][v]",
"+ for i in range(-2, 3):",
"+ for j in range(-2, 3):",
"+ if 0 <= u + i < h and 0 <= v + j < w and S[u + i][v + j] == \".\":",
"+ if (i, j) in steps:",
"+ if d < dist[u + i][v + j]:",
"+ dist[u + i][v + j] = d",
"+ queue.appendleft((u + i, v + j))",
"+ else:",
"+ if 1 + d < dist[u + i][v + j]:",
"+ dist[u + i][v + j] = 1 + d",
"+ queue.append((u + i, v + j))"
]
| false | 0.050973 | 0.05169 | 0.986123 | [
"s918354939",
"s691931038"
]
|
u585482323 | p02936 | python | s664467563 | s142173186 | 1,231 | 777 | 56,192 | 94,484 | Accepted | Accepted | 36.88 | #!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from itertools import permutations
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
def dfs(x):
fx = f[x]
for y in v[x]:
if d[y]:
d[y] = 0
f[y] += fx
dfs(y)
n,q = LI()
v = [[] for i in range(n)]
for i in range(n-1):
a,b = LI()
a -= 1
b -= 1
v[a].append(b)
v[b].append(a)
f = [0]*n
for i in range(q):
p,x = LI()
p -= 1
f[p] += x
d = [1]*n
d[0] = 0
q = deque([0])
while q:
x = q.popleft()
fx = f[x]
for y in v[x]:
if d[y]:
d[y] = 0
f[y] += fx
q.append(y)
print(*f,sep=" ")
return
#Solve
if __name__ == "__main__":
solve()
| #!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.buffer.readline().split()]
def I(): return int(sys.stdin.buffer.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n,q = LI()
v = [[] for i in range(n)]
for _ in range(n-1):
a,b = LI()
a -= 1
b -= 1
v[a].append(b)
v[b].append(a)
f = [0]*n
for _ in range(q):
p,x = LI()
p -= 1
f[p] += x
d = [0]*n
d[0] = 1
q = deque([0])
while q:
x = q.popleft()
fx = f[x]
for y in v[x]:
if not d[y]:
d[y] = 1
f[y] += fx
q.append(y)
print((*f))
return
#Solve
if __name__ == "__main__":
solve()
| 65 | 58 | 1,479 | 1,342 | #!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations
import sys
import math
import bisect
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def I():
return int(sys.stdin.readline())
def LS():
return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
def dfs(x):
fx = f[x]
for y in v[x]:
if d[y]:
d[y] = 0
f[y] += fx
dfs(y)
n, q = LI()
v = [[] for i in range(n)]
for i in range(n - 1):
a, b = LI()
a -= 1
b -= 1
v[a].append(b)
v[b].append(a)
f = [0] * n
for i in range(q):
p, x = LI()
p -= 1
f[p] += x
d = [1] * n
d[0] = 0
q = deque([0])
while q:
x = q.popleft()
fx = f[x]
for y in v[x]:
if d[y]:
d[y] = 0
f[y] += fx
q.append(y)
print(*f, sep=" ")
return
# Solve
if __name__ == "__main__":
solve()
| #!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI():
return [int(x) for x in sys.stdin.buffer.readline().split()]
def I():
return int(sys.stdin.buffer.readline())
def LS():
return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n, q = LI()
v = [[] for i in range(n)]
for _ in range(n - 1):
a, b = LI()
a -= 1
b -= 1
v[a].append(b)
v[b].append(a)
f = [0] * n
for _ in range(q):
p, x = LI()
p -= 1
f[p] += x
d = [0] * n
d[0] = 1
q = deque([0])
while q:
x = q.popleft()
fx = f[x]
for y in v[x]:
if not d[y]:
d[y] = 1
f[y] += fx
q.append(y)
print((*f))
return
# Solve
if __name__ == "__main__":
solve()
| false | 10.769231 | [
"-from itertools import permutations",
"+from itertools import permutations, accumulate",
"- return [int(x) for x in sys.stdin.readline().split()]",
"+ return [int(x) for x in sys.stdin.buffer.readline().split()]",
"- return int(sys.stdin.readline())",
"+ return int(sys.stdin.buffer.readline())",
"- def dfs(x):",
"- fx = f[x]",
"- for y in v[x]:",
"- if d[y]:",
"- d[y] = 0",
"- f[y] += fx",
"- dfs(y)",
"-",
"- for i in range(n - 1):",
"+ for _ in range(n - 1):",
"- for i in range(q):",
"+ for _ in range(q):",
"- d = [1] * n",
"- d[0] = 0",
"+ d = [0] * n",
"+ d[0] = 1",
"- if d[y]:",
"- d[y] = 0",
"+ if not d[y]:",
"+ d[y] = 1",
"- print(*f, sep=\" \")",
"+ print((*f))"
]
| false | 0.1503 | 0.158482 | 0.948373 | [
"s664467563",
"s142173186"
]
|
u914330401 | p03273 | python | s394060150 | s067075416 | 33 | 18 | 4,596 | 3,064 | Accepted | Accepted | 45.45 | H, W = map(int, input().split())
ans = []
# 横白の除去
for h in range(H):
line = input()
if "#" in line:
ans.append(line)
H = len(ans)
W = len(ans[0])
# 縦白の除去
rem_list = []
for w in range(W):
ver = [s[w] for s in ans]
if "#" in ver:
continue
rem_list.append(w)
for h in range(H):
new_ans = []
for w in range(W):
if w in rem_list:
continue
new_ans.append(ans[h][w])
ans[h] = new_ans
for i in range(len(ans)):
for j in range(len(ans[0])):
print(ans[i][j], end="")
if j >= len(ans[0])-1:
print()
| H, W = list(map(int, input().split()))
ans = []
# 横白の除去
for h in range(H):
line = eval(input())
if "#" in line:
ans.append(line)
lines = list(zip(*ans))
ans = []
# 縦白の除去
for line in lines:
if "#" in line:
ans.append(line)
an = list(zip(*ans))
for line in an:
print((''.join(line))) | 33 | 21 | 633 | 312 | H, W = map(int, input().split())
ans = []
# 横白の除去
for h in range(H):
line = input()
if "#" in line:
ans.append(line)
H = len(ans)
W = len(ans[0])
# 縦白の除去
rem_list = []
for w in range(W):
ver = [s[w] for s in ans]
if "#" in ver:
continue
rem_list.append(w)
for h in range(H):
new_ans = []
for w in range(W):
if w in rem_list:
continue
new_ans.append(ans[h][w])
ans[h] = new_ans
for i in range(len(ans)):
for j in range(len(ans[0])):
print(ans[i][j], end="")
if j >= len(ans[0]) - 1:
print()
| H, W = list(map(int, input().split()))
ans = []
# 横白の除去
for h in range(H):
line = eval(input())
if "#" in line:
ans.append(line)
lines = list(zip(*ans))
ans = []
# 縦白の除去
for line in lines:
if "#" in line:
ans.append(line)
an = list(zip(*ans))
for line in an:
print(("".join(line)))
| false | 36.363636 | [
"-H, W = map(int, input().split())",
"+H, W = list(map(int, input().split()))",
"- line = input()",
"+ line = eval(input())",
"-H = len(ans)",
"-W = len(ans[0])",
"+lines = list(zip(*ans))",
"+ans = []",
"-rem_list = []",
"-for w in range(W):",
"- ver = [s[w] for s in ans]",
"- if \"#\" in ver:",
"- continue",
"- rem_list.append(w)",
"-for h in range(H):",
"- new_ans = []",
"- for w in range(W):",
"- if w in rem_list:",
"- continue",
"- new_ans.append(ans[h][w])",
"- ans[h] = new_ans",
"-for i in range(len(ans)):",
"- for j in range(len(ans[0])):",
"- print(ans[i][j], end=\"\")",
"- if j >= len(ans[0]) - 1:",
"- print()",
"+for line in lines:",
"+ if \"#\" in line:",
"+ ans.append(line)",
"+an = list(zip(*ans))",
"+for line in an:",
"+ print((\"\".join(line)))"
]
| false | 0.046268 | 0.0474 | 0.976118 | [
"s394060150",
"s067075416"
]
|
u296518383 | p03103 | python | s011605012 | s964803298 | 490 | 300 | 29,792 | 28,584 | Accepted | Accepted | 38.78 | N,M=list(map(int,input().split()))
AB=[]
for i in range(N):
AB.append(list(map(int,input().split())))
AB=sorted(AB,key=lambda x: x[0])
#print(AB)
ans=0
num=0
for i in range(N):
if num+AB[i][1]>=M:
ans+=AB[i][0]*(M-num)
break
else:
num+=AB[i][1]
ans+=AB[i][0]*AB[i][1]
#print(ans)
print(ans) | import sys
input = sys.stdin.buffer.readline
N, M = list(map(int, input().split()))
AB = [list(map(int, input().split())) for _ in range(N)]
AB = sorted(AB)
answer = 0
for a, b in AB:
if M > b:
answer += a * b
M -= b
else:
answer += a * M
break
print(answer) | 18 | 18 | 326 | 293 | N, M = list(map(int, input().split()))
AB = []
for i in range(N):
AB.append(list(map(int, input().split())))
AB = sorted(AB, key=lambda x: x[0])
# print(AB)
ans = 0
num = 0
for i in range(N):
if num + AB[i][1] >= M:
ans += AB[i][0] * (M - num)
break
else:
num += AB[i][1]
ans += AB[i][0] * AB[i][1]
# print(ans)
print(ans)
| import sys
input = sys.stdin.buffer.readline
N, M = list(map(int, input().split()))
AB = [list(map(int, input().split())) for _ in range(N)]
AB = sorted(AB)
answer = 0
for a, b in AB:
if M > b:
answer += a * b
M -= b
else:
answer += a * M
break
print(answer)
| false | 0 | [
"+import sys",
"+",
"+input = sys.stdin.buffer.readline",
"-AB = []",
"-for i in range(N):",
"- AB.append(list(map(int, input().split())))",
"-AB = sorted(AB, key=lambda x: x[0])",
"-# print(AB)",
"-ans = 0",
"-num = 0",
"-for i in range(N):",
"- if num + AB[i][1] >= M:",
"- ans += AB[i][0] * (M - num)",
"+AB = [list(map(int, input().split())) for _ in range(N)]",
"+AB = sorted(AB)",
"+answer = 0",
"+for a, b in AB:",
"+ if M > b:",
"+ answer += a * b",
"+ M -= b",
"+ else:",
"+ answer += a * M",
"- else:",
"- num += AB[i][1]",
"- ans += AB[i][0] * AB[i][1]",
"- # print(ans)",
"-print(ans)",
"+print(answer)"
]
| false | 0.033701 | 0.036814 | 0.915437 | [
"s011605012",
"s964803298"
]
|
u047393579 | p03745 | python | s641394282 | s283415855 | 227 | 79 | 62,832 | 14,252 | Accepted | Accepted | 65.2 | N = int(eval(input()))
selector = 0
count = 1
A = [int(i) for i in input().split()]
pre_num = A[0]
for num in A[1:]:
if selector == 0:
selector = num - pre_num
if selector > 0:
if num < pre_num:
selector = 0
count += 1
if selector < 0:
if num > pre_num:
selector = 0
count += 1
pre_num = num
print(count) | N = int(eval(input()))
sub = 0
count = 1
A = [int(i) for i in input().split()]
if N > 1:
pre_num = A[1]
pre_sub = A[1] - A[0]
for num in A[2:]:
if not pre_num == num:
if pre_sub * (num - pre_num) < 0:
count += 1
pre_sub = 0
else:
pre_sub = num - pre_num
pre_num = num
print(count) | 18 | 16 | 403 | 354 | N = int(eval(input()))
selector = 0
count = 1
A = [int(i) for i in input().split()]
pre_num = A[0]
for num in A[1:]:
if selector == 0:
selector = num - pre_num
if selector > 0:
if num < pre_num:
selector = 0
count += 1
if selector < 0:
if num > pre_num:
selector = 0
count += 1
pre_num = num
print(count)
| N = int(eval(input()))
sub = 0
count = 1
A = [int(i) for i in input().split()]
if N > 1:
pre_num = A[1]
pre_sub = A[1] - A[0]
for num in A[2:]:
if not pre_num == num:
if pre_sub * (num - pre_num) < 0:
count += 1
pre_sub = 0
else:
pre_sub = num - pre_num
pre_num = num
print(count)
| false | 11.111111 | [
"-selector = 0",
"+sub = 0",
"-pre_num = A[0]",
"-for num in A[1:]:",
"- if selector == 0:",
"- selector = num - pre_num",
"- if selector > 0:",
"- if num < pre_num:",
"- selector = 0",
"+if N > 1:",
"+ pre_num = A[1]",
"+ pre_sub = A[1] - A[0]",
"+for num in A[2:]:",
"+ if not pre_num == num:",
"+ if pre_sub * (num - pre_num) < 0:",
"- if selector < 0:",
"- if num > pre_num:",
"- selector = 0",
"- count += 1",
"- pre_num = num",
"+ pre_sub = 0",
"+ else:",
"+ pre_sub = num - pre_num",
"+ pre_num = num"
]
| false | 0.036834 | 0.095121 | 0.387237 | [
"s641394282",
"s283415855"
]
|
u929217794 | p02627 | python | s899980735 | s944313162 | 30 | 25 | 9,068 | 9,060 | Accepted | Accepted | 16.67 | inp = eval(input())
if inp.isupper():
print("A")
elif inp.islower():
print("a")
| a = eval(input())
if a.isupper():
print("A")
elif a.islower():
print("a") | 6 | 6 | 88 | 77 | inp = eval(input())
if inp.isupper():
print("A")
elif inp.islower():
print("a")
| a = eval(input())
if a.isupper():
print("A")
elif a.islower():
print("a")
| false | 0 | [
"-inp = eval(input())",
"-if inp.isupper():",
"+a = eval(input())",
"+if a.isupper():",
"-elif inp.islower():",
"+elif a.islower():"
]
| false | 0.08466 | 0.044299 | 1.911128 | [
"s899980735",
"s944313162"
]
|
u046592970 | p03644 | python | s763668113 | s509852076 | 19 | 17 | 3,060 | 3,060 | Accepted | Accepted | 10.53 | import math
n = int(eval(input()))
x = int(math.log2(n))
print((2**x)) | n = int(eval(input()))
ansc = 0
ans = 0
if n == 1:
print((1))
exit()
for i in range(1,n+1):
x = i
cnt = 0
while x % 2 == 0:
cnt += 1
x /= 2
if cnt > ansc:
ansc = cnt
ans = i
print(ans) | 4 | 16 | 65 | 259 | import math
n = int(eval(input()))
x = int(math.log2(n))
print((2**x))
| n = int(eval(input()))
ansc = 0
ans = 0
if n == 1:
print((1))
exit()
for i in range(1, n + 1):
x = i
cnt = 0
while x % 2 == 0:
cnt += 1
x /= 2
if cnt > ansc:
ansc = cnt
ans = i
print(ans)
| false | 75 | [
"-import math",
"-",
"-x = int(math.log2(n))",
"-print((2**x))",
"+ansc = 0",
"+ans = 0",
"+if n == 1:",
"+ print((1))",
"+ exit()",
"+for i in range(1, n + 1):",
"+ x = i",
"+ cnt = 0",
"+ while x % 2 == 0:",
"+ cnt += 1",
"+ x /= 2",
"+ if cnt > ansc:",
"+ ansc = cnt",
"+ ans = i",
"+print(ans)"
]
| false | 0.07387 | 0.080518 | 0.917435 | [
"s763668113",
"s509852076"
]
|
u679325651 | p03031 | python | s289230707 | s305937012 | 44 | 22 | 3,064 | 3,064 | Accepted | Accepted | 50 | N,M = [int(i) for i in input().split()] #Nがスイッチの数、Mは電球の数
kslist = []
for i in range(M):
kslist.append([int(i)-1 for i in input().split()][1:])
plist = [int(i) for i in input().split()]
#print(kslist)
#print(plist)
count = 0
lamp_str = "0"*N
for i in range(2**N):
lamp_onoff_list = [int(i) for i in lamp_str]
iflampturnson = [0 for i in range(M)]
for j in range(M):
for s in kslist[j]:
iflampturnson[j] += lamp_onoff_list[s]
#print(lamp_onoff_list,iflampturnson)
iflampturnson = [k%2 for k in iflampturnson]
buff = True
for k in range(M):
if plist[k] != iflampturnson[k]:
buff = False
if buff == True:
count += 1
lamp_str = format(int(lamp_str,2) + 1,"b")
lamp_str = lamp_str.zfill(N)
print(count)
| N,M = [int(i) for i in input().split()]
switches = []
for i in range(M):
buff = 0
k,*sss = [int(i) for i in input().split()]
for s in sss:
buff += 1 << (s-1)
switches.append(buff)
ppp = [int(i) for i in input().split()]
ans = 0
for i in range(1<<N):
for p,s in zip(ppp,switches):
buff = s&i
buff = bin(buff).count("1")%2
if buff != p:
break
else:
ans += 1
print(ans) | 33 | 21 | 832 | 464 | N, M = [int(i) for i in input().split()] # Nがスイッチの数、Mは電球の数
kslist = []
for i in range(M):
kslist.append([int(i) - 1 for i in input().split()][1:])
plist = [int(i) for i in input().split()]
# print(kslist)
# print(plist)
count = 0
lamp_str = "0" * N
for i in range(2**N):
lamp_onoff_list = [int(i) for i in lamp_str]
iflampturnson = [0 for i in range(M)]
for j in range(M):
for s in kslist[j]:
iflampturnson[j] += lamp_onoff_list[s]
# print(lamp_onoff_list,iflampturnson)
iflampturnson = [k % 2 for k in iflampturnson]
buff = True
for k in range(M):
if plist[k] != iflampturnson[k]:
buff = False
if buff == True:
count += 1
lamp_str = format(int(lamp_str, 2) + 1, "b")
lamp_str = lamp_str.zfill(N)
print(count)
| N, M = [int(i) for i in input().split()]
switches = []
for i in range(M):
buff = 0
k, *sss = [int(i) for i in input().split()]
for s in sss:
buff += 1 << (s - 1)
switches.append(buff)
ppp = [int(i) for i in input().split()]
ans = 0
for i in range(1 << N):
for p, s in zip(ppp, switches):
buff = s & i
buff = bin(buff).count("1") % 2
if buff != p:
break
else:
ans += 1
print(ans)
| false | 36.363636 | [
"-N, M = [int(i) for i in input().split()] # Nがスイッチの数、Mは電球の数",
"-kslist = []",
"+N, M = [int(i) for i in input().split()]",
"+switches = []",
"- kslist.append([int(i) - 1 for i in input().split()][1:])",
"-plist = [int(i) for i in input().split()]",
"-# print(kslist)",
"-# print(plist)",
"-count = 0",
"-lamp_str = \"0\" * N",
"-for i in range(2**N):",
"- lamp_onoff_list = [int(i) for i in lamp_str]",
"- iflampturnson = [0 for i in range(M)]",
"- for j in range(M):",
"- for s in kslist[j]:",
"- iflampturnson[j] += lamp_onoff_list[s]",
"- # print(lamp_onoff_list,iflampturnson)",
"- iflampturnson = [k % 2 for k in iflampturnson]",
"- buff = True",
"- for k in range(M):",
"- if plist[k] != iflampturnson[k]:",
"- buff = False",
"- if buff == True:",
"- count += 1",
"- lamp_str = format(int(lamp_str, 2) + 1, \"b\")",
"- lamp_str = lamp_str.zfill(N)",
"-print(count)",
"+ buff = 0",
"+ k, *sss = [int(i) for i in input().split()]",
"+ for s in sss:",
"+ buff += 1 << (s - 1)",
"+ switches.append(buff)",
"+ppp = [int(i) for i in input().split()]",
"+ans = 0",
"+for i in range(1 << N):",
"+ for p, s in zip(ppp, switches):",
"+ buff = s & i",
"+ buff = bin(buff).count(\"1\") % 2",
"+ if buff != p:",
"+ break",
"+ else:",
"+ ans += 1",
"+print(ans)"
]
| false | 0.036492 | 0.07486 | 0.48747 | [
"s289230707",
"s305937012"
]
|
u178946688 | p02622 | python | s392364695 | s745463373 | 72 | 62 | 9,572 | 9,552 | Accepted | Accepted | 13.89 | S = eval(input())
T = eval(input())
U = S + T[::-1]
count = 0
for i in range(int(len(U)/2)):
if U[i] != U[-(i+1)]:
count += 1
print(count) | S = eval(input())
T = eval(input())
count = 0
for i in range(len(S)):
if S[i] != T[i]:
count += 1
print(count) | 8 | 7 | 139 | 110 | S = eval(input())
T = eval(input())
U = S + T[::-1]
count = 0
for i in range(int(len(U) / 2)):
if U[i] != U[-(i + 1)]:
count += 1
print(count)
| S = eval(input())
T = eval(input())
count = 0
for i in range(len(S)):
if S[i] != T[i]:
count += 1
print(count)
| false | 12.5 | [
"-U = S + T[::-1]",
"-for i in range(int(len(U) / 2)):",
"- if U[i] != U[-(i + 1)]:",
"+for i in range(len(S)):",
"+ if S[i] != T[i]:"
]
| false | 0.080098 | 0.037104 | 2.158735 | [
"s392364695",
"s745463373"
]
|
u644907318 | p03721 | python | s771712384 | s586474269 | 701 | 309 | 65,240 | 94,460 | Accepted | Accepted | 55.92 | N,K = list(map(int,input().split()))
A = sorted([list(map(int,input().split())) for _ in range(N)],key=lambda x:x[0])
cnt = 0
for i in range(N):
cnt += A[i][1]
if cnt>=K:
print((A[i][0]))
break | N,K = list(map(int,input().split()))
A = sorted([list(map(int,input().split())) for _ in range(N)],key=lambda x:x[0])
cnt = 0
i = 0
while i<N:
a,b = A[i]
if cnt+b<=K:
cnt += b
else:
break
i += 1
if cnt==K:
print((A[i-1][0]))
else:
print((A[i][0])) | 8 | 15 | 216 | 291 | N, K = list(map(int, input().split()))
A = sorted([list(map(int, input().split())) for _ in range(N)], key=lambda x: x[0])
cnt = 0
for i in range(N):
cnt += A[i][1]
if cnt >= K:
print((A[i][0]))
break
| N, K = list(map(int, input().split()))
A = sorted([list(map(int, input().split())) for _ in range(N)], key=lambda x: x[0])
cnt = 0
i = 0
while i < N:
a, b = A[i]
if cnt + b <= K:
cnt += b
else:
break
i += 1
if cnt == K:
print((A[i - 1][0]))
else:
print((A[i][0]))
| false | 46.666667 | [
"-for i in range(N):",
"- cnt += A[i][1]",
"- if cnt >= K:",
"- print((A[i][0]))",
"+i = 0",
"+while i < N:",
"+ a, b = A[i]",
"+ if cnt + b <= K:",
"+ cnt += b",
"+ else:",
"+ i += 1",
"+if cnt == K:",
"+ print((A[i - 1][0]))",
"+else:",
"+ print((A[i][0]))"
]
| false | 0.047716 | 0.055401 | 0.861287 | [
"s771712384",
"s586474269"
]
|
u230621983 | p03037 | python | s405484069 | s647572699 | 324 | 218 | 3,060 | 9,196 | Accepted | Accepted | 32.72 | n, m = list(map(int, input().split()))
l_max = 1
r_min = n
for _ in range(m):
l,r = list(map(int, input().split()))
l_max = max(l_max, l)
r_min = min(r_min, r)
print((max(0,r_min-l_max+1))) | n, m = list(map(int, input().split()))
max_l = 0
min_r = n
for _ in range(m):
l, r = list(map(int, input().split()))
max_l = max(l, max_l)
min_r = min(r, min_r)
print((max(min_r - max_l + 1, 0))) | 9 | 8 | 200 | 200 | n, m = list(map(int, input().split()))
l_max = 1
r_min = n
for _ in range(m):
l, r = list(map(int, input().split()))
l_max = max(l_max, l)
r_min = min(r_min, r)
print((max(0, r_min - l_max + 1)))
| n, m = list(map(int, input().split()))
max_l = 0
min_r = n
for _ in range(m):
l, r = list(map(int, input().split()))
max_l = max(l, max_l)
min_r = min(r, min_r)
print((max(min_r - max_l + 1, 0)))
| false | 11.111111 | [
"-l_max = 1",
"-r_min = n",
"+max_l = 0",
"+min_r = n",
"- l_max = max(l_max, l)",
"- r_min = min(r_min, r)",
"-print((max(0, r_min - l_max + 1)))",
"+ max_l = max(l, max_l)",
"+ min_r = min(r, min_r)",
"+print((max(min_r - max_l + 1, 0)))"
]
| false | 0.037217 | 0.044373 | 0.838741 | [
"s405484069",
"s647572699"
]
|
u261103969 | p03111 | python | s085312468 | s112294634 | 321 | 173 | 47,964 | 10,996 | Accepted | Accepted | 46.11 | import sys
# import bisect
from collections import Counter, deque, defaultdict
# import copy
# from heapq import heappush, heappop, heapify
# from fractions import gcd
import itertools
from operator import attrgetter, itemgetter
# import math
# import numpy as np
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
n, a, b, c = list(map(int, readline().split()))
l = [int(eval(input())) for _ in range(n)]
ans = INF
base_idx = list(itertools.permutations(list(range(n)), r=3))
for bi in base_idx:
bamboo_length = [0] * 3
add_bamboo = list(itertools.product(list(range(4)), repeat=(n-3)))
rem_idx = [i for i in range(n) if i not in bi]
for ai in add_bamboo:
mp = 0
bamboo_length[0] = l[bi[0]]
bamboo_length[1] = l[bi[1]]
bamboo_length[2] = l[bi[2]]
for idx, num in enumerate(ai):
if num != 3:
bamboo_length[num] += l[rem_idx[idx]]
mp += 10
mp += abs(a - bamboo_length[0])
mp += abs(b - bamboo_length[1])
mp += abs(c - bamboo_length[2])
ans = min(mp, ans)
print(ans)
if __name__ == '__main__':
main()
| import sys
# import bisect
# from collections import Counter, deque, defaultdict
# import copy
# from heapq import heappush, heappop, heapify
# from fractions import gcd
import itertools
# from operator import attrgetter, itemgetter
# import math
# import numpy as np
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
n, a, b, c = list(map(int, readline().split()))
l = [int(eval(input())) for _ in range(n)]
ans = INF
selects = list(itertools.product(list(range(4)), repeat=n))
for select in selects:
mp = -30
bamboo_length = [0] * 3
for i, num in enumerate(select):
if num != 3:
bamboo_length[num] += l[i]
mp += 10
for length in bamboo_length:
if length == 0:
break
else:
mp += abs(a - bamboo_length[0])
mp += abs(b - bamboo_length[1])
mp += abs(c - bamboo_length[2])
ans = min(mp, ans)
print(ans)
if __name__ == '__main__':
main()
| 52 | 49 | 1,328 | 1,130 | import sys
# import bisect
from collections import Counter, deque, defaultdict
# import copy
# from heapq import heappush, heappop, heapify
# from fractions import gcd
import itertools
from operator import attrgetter, itemgetter
# import math
# import numpy as np
readline = sys.stdin.readline
MOD = 10**9 + 7
INF = float("INF")
sys.setrecursionlimit(10**5)
def main():
n, a, b, c = list(map(int, readline().split()))
l = [int(eval(input())) for _ in range(n)]
ans = INF
base_idx = list(itertools.permutations(list(range(n)), r=3))
for bi in base_idx:
bamboo_length = [0] * 3
add_bamboo = list(itertools.product(list(range(4)), repeat=(n - 3)))
rem_idx = [i for i in range(n) if i not in bi]
for ai in add_bamboo:
mp = 0
bamboo_length[0] = l[bi[0]]
bamboo_length[1] = l[bi[1]]
bamboo_length[2] = l[bi[2]]
for idx, num in enumerate(ai):
if num != 3:
bamboo_length[num] += l[rem_idx[idx]]
mp += 10
mp += abs(a - bamboo_length[0])
mp += abs(b - bamboo_length[1])
mp += abs(c - bamboo_length[2])
ans = min(mp, ans)
print(ans)
if __name__ == "__main__":
main()
| import sys
# import bisect
# from collections import Counter, deque, defaultdict
# import copy
# from heapq import heappush, heappop, heapify
# from fractions import gcd
import itertools
# from operator import attrgetter, itemgetter
# import math
# import numpy as np
readline = sys.stdin.readline
MOD = 10**9 + 7
INF = float("INF")
sys.setrecursionlimit(10**5)
def main():
n, a, b, c = list(map(int, readline().split()))
l = [int(eval(input())) for _ in range(n)]
ans = INF
selects = list(itertools.product(list(range(4)), repeat=n))
for select in selects:
mp = -30
bamboo_length = [0] * 3
for i, num in enumerate(select):
if num != 3:
bamboo_length[num] += l[i]
mp += 10
for length in bamboo_length:
if length == 0:
break
else:
mp += abs(a - bamboo_length[0])
mp += abs(b - bamboo_length[1])
mp += abs(c - bamboo_length[2])
ans = min(mp, ans)
print(ans)
if __name__ == "__main__":
main()
| false | 5.769231 | [
"-from collections import Counter, deque, defaultdict",
"-",
"+# from collections import Counter, deque, defaultdict",
"-from operator import attrgetter, itemgetter",
"+# from operator import attrgetter, itemgetter",
"- base_idx = list(itertools.permutations(list(range(n)), r=3))",
"- for bi in base_idx:",
"+ selects = list(itertools.product(list(range(4)), repeat=n))",
"+ for select in selects:",
"+ mp = -30",
"- add_bamboo = list(itertools.product(list(range(4)), repeat=(n - 3)))",
"- rem_idx = [i for i in range(n) if i not in bi]",
"- for ai in add_bamboo:",
"- mp = 0",
"- bamboo_length[0] = l[bi[0]]",
"- bamboo_length[1] = l[bi[1]]",
"- bamboo_length[2] = l[bi[2]]",
"- for idx, num in enumerate(ai):",
"- if num != 3:",
"- bamboo_length[num] += l[rem_idx[idx]]",
"- mp += 10",
"+ for i, num in enumerate(select):",
"+ if num != 3:",
"+ bamboo_length[num] += l[i]",
"+ mp += 10",
"+ for length in bamboo_length:",
"+ if length == 0:",
"+ break",
"+ else:"
]
| false | 0.450892 | 0.379815 | 1.187137 | [
"s085312468",
"s112294634"
]
|
u588341295 | p02588 | python | s298739434 | s930373924 | 331 | 179 | 85,224 | 71,072 | Accepted | Accepted | 45.92 | 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 ** 19
MOD = 10 ** 19 + 7
EPS = 10 ** -10
def gcd(a, b):
while b: a, b = b, a % b
return a
N = INT()
K = 10**9
L = 10**18
A = [0] * N
C = Counter()
for i in range(N):
a = float(eval(input()))
A[i] = round(a * K)
C[gcd(A[i], L)] += 1
ans = 0
for k1, v1 in list(C.items()):
for k2, v2 in list(C.items()):
if k1 == k2:
if k1*k2 % L == 0:
ans += v1*(v1-1) // 2
elif k1 < k2:
if k1*k2 % L == 0:
ans += v1 * v2
print(ans)
| import sys
from collections import Counter
from math import gcd
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 ** 19
MOD = 10 ** 19 + 7
EPS = 10 ** -10
N = INT()
K = 10**9
L = 10**18
A = [0] * N
C = Counter()
for i in range(N):
a = float(eval(input()))
# ここint()だと切り捨てでバグる
A[i] = round(a * K)
C[gcd(A[i], L)] += 1
ans = 0
for k1, v1 in list(C.items()):
for k2, v2 in list(C.items()):
if k1 == k2:
if k1*k2 % L == 0:
ans += v1*(v1-1) // 2
elif k1 < k2:
if k1*k2 % L == 0:
ans += v1 * v2
print(ans)
| 44 | 42 | 1,198 | 1,183 | 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**19
MOD = 10**19 + 7
EPS = 10**-10
def gcd(a, b):
while b:
a, b = b, a % b
return a
N = INT()
K = 10**9
L = 10**18
A = [0] * N
C = Counter()
for i in range(N):
a = float(eval(input()))
A[i] = round(a * K)
C[gcd(A[i], L)] += 1
ans = 0
for k1, v1 in list(C.items()):
for k2, v2 in list(C.items()):
if k1 == k2:
if k1 * k2 % L == 0:
ans += v1 * (v1 - 1) // 2
elif k1 < k2:
if k1 * k2 % L == 0:
ans += v1 * v2
print(ans)
| import sys
from collections import Counter
from math import gcd
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**19
MOD = 10**19 + 7
EPS = 10**-10
N = INT()
K = 10**9
L = 10**18
A = [0] * N
C = Counter()
for i in range(N):
a = float(eval(input()))
# ここint()だと切り捨てでバグる
A[i] = round(a * K)
C[gcd(A[i], L)] += 1
ans = 0
for k1, v1 in list(C.items()):
for k2, v2 in list(C.items()):
if k1 == k2:
if k1 * k2 % L == 0:
ans += v1 * (v1 - 1) // 2
elif k1 < k2:
if k1 * k2 % L == 0:
ans += v1 * v2
print(ans)
| false | 4.545455 | [
"+from math import gcd",
"-",
"-",
"-def gcd(a, b):",
"- while b:",
"- a, b = b, a % b",
"- return a",
"-",
"-",
"+ # ここint()だと切り捨てでバグる"
]
| false | 0.036935 | 0.115055 | 0.321024 | [
"s298739434",
"s930373924"
]
|
u953110527 | p02683 | python | s337125143 | s944315409 | 84 | 30 | 9,144 | 9,136 | Accepted | Accepted | 64.29 | n,m,x = list(map(int,input().split()))
cost = []
a = []
for i in range(n):
ca = list(map(int,input().split()))
cost.append(ca[0])
a.append(ca[1:])
ans = 10**7
for bit in range(2**n):
alg = [0 for i in range(m)]
ccount = 0
for i in range(n):
if bit >> i & 1:
for j in range(m):
alg[j] += a[i][j]
ccount += cost[i]
if min(alg) >= x:
ans = min(ans,ccount)
if ans == 10**7:
print((-1))
else:
print(ans) | n,m,x = list(map(int,input().split()))
c = []
for i in range(n):
ci = list(map(int,input().split()))
c.append(ci)
t = [0 for i in range(m+1)]
def dfs(l,i):
if i == n:
if min(l[1:]) >= x:
return l[0]
else:
return 10**9
d = l[:]
for j in range(m+1):
d[j] += c[i][j]
return min(dfs(l,i+1),dfs(d,i+1))
ans = dfs(t,0)
if ans == 10**9:
print((-1))
exit()
print(ans) | 23 | 21 | 505 | 451 | n, m, x = list(map(int, input().split()))
cost = []
a = []
for i in range(n):
ca = list(map(int, input().split()))
cost.append(ca[0])
a.append(ca[1:])
ans = 10**7
for bit in range(2**n):
alg = [0 for i in range(m)]
ccount = 0
for i in range(n):
if bit >> i & 1:
for j in range(m):
alg[j] += a[i][j]
ccount += cost[i]
if min(alg) >= x:
ans = min(ans, ccount)
if ans == 10**7:
print((-1))
else:
print(ans)
| n, m, x = list(map(int, input().split()))
c = []
for i in range(n):
ci = list(map(int, input().split()))
c.append(ci)
t = [0 for i in range(m + 1)]
def dfs(l, i):
if i == n:
if min(l[1:]) >= x:
return l[0]
else:
return 10**9
d = l[:]
for j in range(m + 1):
d[j] += c[i][j]
return min(dfs(l, i + 1), dfs(d, i + 1))
ans = dfs(t, 0)
if ans == 10**9:
print((-1))
exit()
print(ans)
| false | 8.695652 | [
"-cost = []",
"-a = []",
"+c = []",
"- ca = list(map(int, input().split()))",
"- cost.append(ca[0])",
"- a.append(ca[1:])",
"-ans = 10**7",
"-for bit in range(2**n):",
"- alg = [0 for i in range(m)]",
"- ccount = 0",
"- for i in range(n):",
"- if bit >> i & 1:",
"- for j in range(m):",
"- alg[j] += a[i][j]",
"- ccount += cost[i]",
"- if min(alg) >= x:",
"- ans = min(ans, ccount)",
"-if ans == 10**7:",
"+ ci = list(map(int, input().split()))",
"+ c.append(ci)",
"+t = [0 for i in range(m + 1)]",
"+",
"+",
"+def dfs(l, i):",
"+ if i == n:",
"+ if min(l[1:]) >= x:",
"+ return l[0]",
"+ else:",
"+ return 10**9",
"+ d = l[:]",
"+ for j in range(m + 1):",
"+ d[j] += c[i][j]",
"+ return min(dfs(l, i + 1), dfs(d, i + 1))",
"+",
"+",
"+ans = dfs(t, 0)",
"+if ans == 10**9:",
"-else:",
"- print(ans)",
"+ exit()",
"+print(ans)"
]
| false | 0.044257 | 0.060244 | 0.734626 | [
"s337125143",
"s944315409"
]
|
u761320129 | p02844 | python | s972211183 | s963631241 | 1,104 | 979 | 5,824 | 5,572 | Accepted | Accepted | 11.32 | N = int(eval(input()))
S = eval(input())
lc = [0]
for c in S:
lc.append(lc[-1] | (1<<int(c)))
rc = [0]
for c in S[::-1]:
rc.append(rc[-1] | (1<<int(c)))
rc.reverse()
mem = [set() for _ in range(10)]
for c,l,r in zip(S,lc,rc[1:]):
c = int(c)
for i in range(10):
if l&(1<<i)==0: continue
for j in range(10):
if r&(1<<j)==0: continue
mem[c].add(10*i+j)
print((sum(len(m) for m in mem))) | N = int(eval(input()))
S = eval(input())
lcs = [0]
rcs = [0]
for c in S:
c = int(c)
lcs.append(lcs[-1] | (1<<c))
for c in S[::-1]:
c = int(c)
rcs.append(rcs[-1] | (1<<c))
rcs.reverse()
ss = set()
for i,c in enumerate(S):
c = int(c)
ls = []
for l in range(10):
if lcs[i]&(1<<l):
ls.append(l)
rs = []
for r in range(10):
if rcs[i+1]&(1<<r):
rs.append(r)
for l in ls:
for r in rs:
ss.add(l*100 + c*10 + r)
print((len(ss))) | 20 | 28 | 446 | 534 | N = int(eval(input()))
S = eval(input())
lc = [0]
for c in S:
lc.append(lc[-1] | (1 << int(c)))
rc = [0]
for c in S[::-1]:
rc.append(rc[-1] | (1 << int(c)))
rc.reverse()
mem = [set() for _ in range(10)]
for c, l, r in zip(S, lc, rc[1:]):
c = int(c)
for i in range(10):
if l & (1 << i) == 0:
continue
for j in range(10):
if r & (1 << j) == 0:
continue
mem[c].add(10 * i + j)
print((sum(len(m) for m in mem)))
| N = int(eval(input()))
S = eval(input())
lcs = [0]
rcs = [0]
for c in S:
c = int(c)
lcs.append(lcs[-1] | (1 << c))
for c in S[::-1]:
c = int(c)
rcs.append(rcs[-1] | (1 << c))
rcs.reverse()
ss = set()
for i, c in enumerate(S):
c = int(c)
ls = []
for l in range(10):
if lcs[i] & (1 << l):
ls.append(l)
rs = []
for r in range(10):
if rcs[i + 1] & (1 << r):
rs.append(r)
for l in ls:
for r in rs:
ss.add(l * 100 + c * 10 + r)
print((len(ss)))
| false | 28.571429 | [
"-lc = [0]",
"+lcs = [0]",
"+rcs = [0]",
"- lc.append(lc[-1] | (1 << int(c)))",
"-rc = [0]",
"+ c = int(c)",
"+ lcs.append(lcs[-1] | (1 << c))",
"- rc.append(rc[-1] | (1 << int(c)))",
"-rc.reverse()",
"-mem = [set() for _ in range(10)]",
"-for c, l, r in zip(S, lc, rc[1:]):",
"- for i in range(10):",
"- if l & (1 << i) == 0:",
"- continue",
"- for j in range(10):",
"- if r & (1 << j) == 0:",
"- continue",
"- mem[c].add(10 * i + j)",
"-print((sum(len(m) for m in mem)))",
"+ rcs.append(rcs[-1] | (1 << c))",
"+rcs.reverse()",
"+ss = set()",
"+for i, c in enumerate(S):",
"+ c = int(c)",
"+ ls = []",
"+ for l in range(10):",
"+ if lcs[i] & (1 << l):",
"+ ls.append(l)",
"+ rs = []",
"+ for r in range(10):",
"+ if rcs[i + 1] & (1 << r):",
"+ rs.append(r)",
"+ for l in ls:",
"+ for r in rs:",
"+ ss.add(l * 100 + c * 10 + r)",
"+print((len(ss)))"
]
| false | 0.040864 | 0.04682 | 0.872793 | [
"s972211183",
"s963631241"
]
|
u802963389 | p03846 | python | s013173921 | s906928562 | 249 | 82 | 58,860 | 13,880 | Accepted | Accepted | 67.07 | from math import ceil
from collections import Counter
N = int(eval(input()))
A = list(map(int, input().split()))
CA = Counter(A)
SCA = sorted(list(CA.items()), key=lambda x:x[0])
if len(CA) != ceil(N / 2):
print((0))
exit()
if N % 2 == 0:
for i, j in zip(SCA, list(range(ceil(N / 2)))):
if not (i[0] == 1 + j * 2 and i[1] == 2):
print((0))
exit()
else:
for i, j in zip(SCA, list(range(ceil(N / 2)))):
if j == 0:
if not (i[0] == j * 2 and i[1] == 1 ):
print((0))
exit()
else:
if not (i[0] == j * 2 and i[1] == 2 ):
print((0))
exit()
print(((2 ** (N // 2)) % (10 ** 9 + 7))) | n = int(eval(input()))
A = list(map(int, input().split()))
MOD = 10 ** 9 + 7
A.sort()
if n % 2 == 0:
if A[::2] == A[1::2] == [i for i in range(1, n + 1, 2)]:
ans = 2 ** (n // 2)
else:
ans = 0
else:
if A == [0] or A[1::2] == A[2::2] == [i for i in range(2, n + 1, 2)]:
ans = 2 ** (n // 2)
else:
ans = 0
print((ans % MOD)) | 28 | 15 | 647 | 350 | from math import ceil
from collections import Counter
N = int(eval(input()))
A = list(map(int, input().split()))
CA = Counter(A)
SCA = sorted(list(CA.items()), key=lambda x: x[0])
if len(CA) != ceil(N / 2):
print((0))
exit()
if N % 2 == 0:
for i, j in zip(SCA, list(range(ceil(N / 2)))):
if not (i[0] == 1 + j * 2 and i[1] == 2):
print((0))
exit()
else:
for i, j in zip(SCA, list(range(ceil(N / 2)))):
if j == 0:
if not (i[0] == j * 2 and i[1] == 1):
print((0))
exit()
else:
if not (i[0] == j * 2 and i[1] == 2):
print((0))
exit()
print(((2 ** (N // 2)) % (10**9 + 7)))
| n = int(eval(input()))
A = list(map(int, input().split()))
MOD = 10**9 + 7
A.sort()
if n % 2 == 0:
if A[::2] == A[1::2] == [i for i in range(1, n + 1, 2)]:
ans = 2 ** (n // 2)
else:
ans = 0
else:
if A == [0] or A[1::2] == A[2::2] == [i for i in range(2, n + 1, 2)]:
ans = 2 ** (n // 2)
else:
ans = 0
print((ans % MOD))
| false | 46.428571 | [
"-from math import ceil",
"-from collections import Counter",
"-",
"-N = int(eval(input()))",
"+n = int(eval(input()))",
"-CA = Counter(A)",
"-SCA = sorted(list(CA.items()), key=lambda x: x[0])",
"-if len(CA) != ceil(N / 2):",
"- print((0))",
"- exit()",
"-if N % 2 == 0:",
"- for i, j in zip(SCA, list(range(ceil(N / 2)))):",
"- if not (i[0] == 1 + j * 2 and i[1] == 2):",
"- print((0))",
"- exit()",
"+MOD = 10**9 + 7",
"+A.sort()",
"+if n % 2 == 0:",
"+ if A[::2] == A[1::2] == [i for i in range(1, n + 1, 2)]:",
"+ ans = 2 ** (n // 2)",
"+ else:",
"+ ans = 0",
"- for i, j in zip(SCA, list(range(ceil(N / 2)))):",
"- if j == 0:",
"- if not (i[0] == j * 2 and i[1] == 1):",
"- print((0))",
"- exit()",
"- else:",
"- if not (i[0] == j * 2 and i[1] == 2):",
"- print((0))",
"- exit()",
"-print(((2 ** (N // 2)) % (10**9 + 7)))",
"+ if A == [0] or A[1::2] == A[2::2] == [i for i in range(2, n + 1, 2)]:",
"+ ans = 2 ** (n // 2)",
"+ else:",
"+ ans = 0",
"+print((ans % MOD))"
]
| false | 0.042721 | 0.056836 | 0.751667 | [
"s013173921",
"s906928562"
]
|
u561231954 | p02918 | python | s823106144 | s417531250 | 48 | 18 | 3,956 | 3,188 | Accepted | Accepted | 62.5 | def main():
n,k=list(map(int,input().split()))
s=eval(input())
A=(('L','R'),('R','L'))
B=[]
Bappend=B.append
cnt=0
for i in range(n-1):
tmp=(s[i],s[i+1])
cnt+=1
if tmp==A[0]:
Bappend(cnt)
cnt=0
elif tmp==A[1]:
Bappend(cnt)
cnt=0
cnt+=1
Bappend(cnt)
print((n-max(1,len(B)-2*k)))
if __name__=='__main__':
main() | def main():
n,k=list(map(int,input().split()))
s=eval(input())
B=s.count('RL')+s.count('LR')+1
print((min(n-1,n-B+2*k)))
if __name__=='__main__':
main() | 23 | 7 | 385 | 158 | def main():
n, k = list(map(int, input().split()))
s = eval(input())
A = (("L", "R"), ("R", "L"))
B = []
Bappend = B.append
cnt = 0
for i in range(n - 1):
tmp = (s[i], s[i + 1])
cnt += 1
if tmp == A[0]:
Bappend(cnt)
cnt = 0
elif tmp == A[1]:
Bappend(cnt)
cnt = 0
cnt += 1
Bappend(cnt)
print((n - max(1, len(B) - 2 * k)))
if __name__ == "__main__":
main()
| def main():
n, k = list(map(int, input().split()))
s = eval(input())
B = s.count("RL") + s.count("LR") + 1
print((min(n - 1, n - B + 2 * k)))
if __name__ == "__main__":
main()
| false | 69.565217 | [
"- A = ((\"L\", \"R\"), (\"R\", \"L\"))",
"- B = []",
"- Bappend = B.append",
"- cnt = 0",
"- for i in range(n - 1):",
"- tmp = (s[i], s[i + 1])",
"- cnt += 1",
"- if tmp == A[0]:",
"- Bappend(cnt)",
"- cnt = 0",
"- elif tmp == A[1]:",
"- Bappend(cnt)",
"- cnt = 0",
"- cnt += 1",
"- Bappend(cnt)",
"- print((n - max(1, len(B) - 2 * k)))",
"+ B = s.count(\"RL\") + s.count(\"LR\") + 1",
"+ print((min(n - 1, n - B + 2 * k)))"
]
| false | 0.046737 | 0.04433 | 1.054296 | [
"s823106144",
"s417531250"
]
|
u891635666 | p03634 | python | s110881104 | s935703394 | 807 | 626 | 169,512 | 131,760 | Accepted | Accepted | 22.43 | import sys
sys.setrecursionlimit(10**6)
input = sys.stdin.readline
n = int(eval(input()))
ls = [list(map(int, input().split())) for _ in range(n - 1)]
es = [[] for _ in range(n + 1)]
for a, b, c in ls:
es[a].append((b, c))
es[b].append((a, c))
ds = [0] * (n + 1)
def dfs(cur, prev, c):
ds[cur] = ds[prev] + c
for e, c in es[cur]:
if e != prev:
dfs(e, cur, c)
q, k = list(map(int, input().split()))
qs = [list(map(int, input().split())) for _ in range(q)]
dfs(k, k, 0)
for x, y in qs:
print((ds[x] + ds[y])) | import sys
sys.setrecursionlimit(10**6)
input = sys.stdin.readline
n = int(eval(input()))
es = [[] for _ in range(n + 1)]
for _ in range(n - 1):
a, b, c = list(map(int, input().split()))
es[a].append((b, c))
es[b].append((a, c))
ds = [0] * (n + 1)
def dfs(cur, prev, c):
ds[cur] = ds[prev] + c
for e, c in es[cur]:
if e != prev:
dfs(e, cur, c)
q, k = list(map(int, input().split()))
dfs(k, k, 0)
for _ in range(q):
x, y = list(map(int, input().split()))
print((ds[x] + ds[y])) | 29 | 29 | 569 | 535 | import sys
sys.setrecursionlimit(10**6)
input = sys.stdin.readline
n = int(eval(input()))
ls = [list(map(int, input().split())) for _ in range(n - 1)]
es = [[] for _ in range(n + 1)]
for a, b, c in ls:
es[a].append((b, c))
es[b].append((a, c))
ds = [0] * (n + 1)
def dfs(cur, prev, c):
ds[cur] = ds[prev] + c
for e, c in es[cur]:
if e != prev:
dfs(e, cur, c)
q, k = list(map(int, input().split()))
qs = [list(map(int, input().split())) for _ in range(q)]
dfs(k, k, 0)
for x, y in qs:
print((ds[x] + ds[y]))
| import sys
sys.setrecursionlimit(10**6)
input = sys.stdin.readline
n = int(eval(input()))
es = [[] for _ in range(n + 1)]
for _ in range(n - 1):
a, b, c = list(map(int, input().split()))
es[a].append((b, c))
es[b].append((a, c))
ds = [0] * (n + 1)
def dfs(cur, prev, c):
ds[cur] = ds[prev] + c
for e, c in es[cur]:
if e != prev:
dfs(e, cur, c)
q, k = list(map(int, input().split()))
dfs(k, k, 0)
for _ in range(q):
x, y = list(map(int, input().split()))
print((ds[x] + ds[y]))
| false | 0 | [
"-ls = [list(map(int, input().split())) for _ in range(n - 1)]",
"-for a, b, c in ls:",
"+for _ in range(n - 1):",
"+ a, b, c = list(map(int, input().split()))",
"-qs = [list(map(int, input().split())) for _ in range(q)]",
"-for x, y in qs:",
"+for _ in range(q):",
"+ x, y = list(map(int, input().split()))"
]
| false | 0.048278 | 0.244334 | 0.197592 | [
"s110881104",
"s935703394"
]
|
u312025627 | p03029 | python | s614021654 | s900406493 | 184 | 17 | 38,384 | 2,940 | Accepted | Accepted | 90.76 | a, p = list(map(int,input().split()))
a_cracked = (a * 3) + p
print((a_cracked//2)) | def main():
A, P = (int(i) for i in input().split())
print(((A*3+P)//2))
if __name__ == '__main__':
main()
| 4 | 7 | 79 | 125 | a, p = list(map(int, input().split()))
a_cracked = (a * 3) + p
print((a_cracked // 2))
| def main():
A, P = (int(i) for i in input().split())
print(((A * 3 + P) // 2))
if __name__ == "__main__":
main()
| false | 42.857143 | [
"-a, p = list(map(int, input().split()))",
"-a_cracked = (a * 3) + p",
"-print((a_cracked // 2))",
"+def main():",
"+ A, P = (int(i) for i in input().split())",
"+ print(((A * 3 + P) // 2))",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
]
| false | 0.074458 | 0.045764 | 1.626977 | [
"s614021654",
"s900406493"
]
|
u076917070 | p02813 | python | s534302815 | s606426250 | 97 | 27 | 3,064 | 8,052 | Accepted | Accepted | 72.16 | import sys
input = sys.stdin.readline
def main():
N = int(eval(input()))
P = list(map(int, input().split()))
Q = list(map(int, input().split()))
ps = ""
for i in P:
ps = ps + str(i)
qs = ""
for i in Q:
qs = qs + str(i)
import itertools
A = [i+1 for i in range(N)]
i = 0
p = q = 0
for a in itertools.permutations(A):
s = ""
for j in a:
s = s + str(j)
if ps == s:
p = i
if qs == s:
q = i
i += 1
print((abs(p-q)))
if __name__ == '__main__':
main()
| import sys
input = sys.stdin.readline
def main():
N = int(eval(input()))
P = tuple(map(int, input().split()))
Q = tuple(map(int, input().split()))
import itertools
a = list(itertools.permutations(list(range(1, N+1))))
print((abs(a.index(P) - a.index(Q))))
if __name__ == '__main__':
main()
| 32 | 16 | 620 | 324 | import sys
input = sys.stdin.readline
def main():
N = int(eval(input()))
P = list(map(int, input().split()))
Q = list(map(int, input().split()))
ps = ""
for i in P:
ps = ps + str(i)
qs = ""
for i in Q:
qs = qs + str(i)
import itertools
A = [i + 1 for i in range(N)]
i = 0
p = q = 0
for a in itertools.permutations(A):
s = ""
for j in a:
s = s + str(j)
if ps == s:
p = i
if qs == s:
q = i
i += 1
print((abs(p - q)))
if __name__ == "__main__":
main()
| import sys
input = sys.stdin.readline
def main():
N = int(eval(input()))
P = tuple(map(int, input().split()))
Q = tuple(map(int, input().split()))
import itertools
a = list(itertools.permutations(list(range(1, N + 1))))
print((abs(a.index(P) - a.index(Q))))
if __name__ == "__main__":
main()
| false | 50 | [
"- P = list(map(int, input().split()))",
"- Q = list(map(int, input().split()))",
"- ps = \"\"",
"- for i in P:",
"- ps = ps + str(i)",
"- qs = \"\"",
"- for i in Q:",
"- qs = qs + str(i)",
"+ P = tuple(map(int, input().split()))",
"+ Q = tuple(map(int, input().split()))",
"- A = [i + 1 for i in range(N)]",
"- i = 0",
"- p = q = 0",
"- for a in itertools.permutations(A):",
"- s = \"\"",
"- for j in a:",
"- s = s + str(j)",
"- if ps == s:",
"- p = i",
"- if qs == s:",
"- q = i",
"- i += 1",
"- print((abs(p - q)))",
"+ a = list(itertools.permutations(list(range(1, N + 1))))",
"+ print((abs(a.index(P) - a.index(Q))))"
]
| false | 0.039165 | 0.109934 | 0.35626 | [
"s534302815",
"s606426250"
]
|
u966207392 | p02612 | python | s852863774 | s743123032 | 29 | 25 | 8,912 | 9,160 | Accepted | Accepted | 13.79 | N = int(eval(input()))
if N >= 1000:
M = str(N)
X = M[1:]
O = int(X)
if O == 0:
print((0))
else:
print((1000-O))
else:
O = int(N)
print((1000-O)) | N = int(eval(input()))
if N % 1000 == 0:
Y = (N // 1000)
print(((Y * 1000) - N))
else:
Y = (N // 1000) + 1
print(((Y * 1000) - N)) | 12 | 7 | 188 | 142 | N = int(eval(input()))
if N >= 1000:
M = str(N)
X = M[1:]
O = int(X)
if O == 0:
print((0))
else:
print((1000 - O))
else:
O = int(N)
print((1000 - O))
| N = int(eval(input()))
if N % 1000 == 0:
Y = N // 1000
print(((Y * 1000) - N))
else:
Y = (N // 1000) + 1
print(((Y * 1000) - N))
| false | 41.666667 | [
"-if N >= 1000:",
"- M = str(N)",
"- X = M[1:]",
"- O = int(X)",
"- if O == 0:",
"- print((0))",
"- else:",
"- print((1000 - O))",
"+if N % 1000 == 0:",
"+ Y = N // 1000",
"+ print(((Y * 1000) - N))",
"- O = int(N)",
"- print((1000 - O))",
"+ Y = (N // 1000) + 1",
"+ print(((Y * 1000) - N))"
]
| false | 0.045214 | 0.039552 | 1.14315 | [
"s852863774",
"s743123032"
]
|
u707124227 | p02703 | python | s746947001 | s691133400 | 1,791 | 876 | 127,300 | 104,296 | Accepted | Accepted | 51.09 | n,m,s=list(map(int,input().split()))
uvab=[list(map(int,input().split())) for _ in range(m)]
cd=[list(map(int,input().split())) for _ in range(n)]
g=[[] for _ in range(n)]
for u,v,a,b in uvab:
u,v=u-1,v-1
g[u].append([v,a,b])
g[v].append([u,a,b])
#「現在いる頂点、現在持っている銀貨枚数」を頂点とし、ダイクストラ法でとく。
from heapq import heappop,heappush
inf=float('inf')
maxs=50*m
ans=[[inf]*(maxs+1) for _ in range(n)]
s=min(s,maxs)
todo=[[0,0,s]]
ans[0][s]=0
while todo:
t,v,ss=heappop(todo)
if ans[v][ss]<t:continue
for nv,na,nb in g[v]:
if na>ss:continue
if ans[nv][ss-na]>t+nb:
heappush(todo,[t+nb,nv,ss-na])
ans[nv][ss-na]=t+nb
c,d=cd[v]
nss=min(ss+c,maxs)
if ans[v][nss]>t+d:
heappush(todo,[t+d,v,nss])
ans[v][nss]=t+d
for i in range(1,n):
print((min(ans[i])))
| n,m,s=list(map(int,input().split()))
uvab=[list(map(int,input().split())) for _ in range(m)]
cd=[list(map(int,input().split())) for _ in range(n)]
g=[[] for _ in range(n)]
maxs=0
for u,v,a,b in uvab:
u,v=u-1,v-1
g[u].append([v,a,b])
g[v].append([u,a,b])
maxs+=a
#「現在いる頂点、現在持っている銀貨枚数」を頂点とし、ダイクストラ法でとく。
from heapq import heappop,heappush
inf=float('inf')
ans=[[inf]*(maxs+1) for _ in range(n)]
s=min(s,maxs)
todo=[[0,0,s]]
ans[0][s]=0
while todo:
t,v,ss=heappop(todo)
if ans[v][ss]<t:continue
for nv,na,nb in g[v]:
if na>ss:continue
if ans[nv][ss-na]>t+nb:
heappush(todo,[t+nb,nv,ss-na])
ans[nv][ss-na]=t+nb
c,d=cd[v]
nss=min(ss+c,maxs)
if ans[v][nss]>t+d:
heappush(todo,[t+d,v,nss])
ans[v][nss]=t+d
for i in range(1,n):
print((min(ans[i])))
| 32 | 34 | 855 | 867 | n, m, s = list(map(int, input().split()))
uvab = [list(map(int, input().split())) for _ in range(m)]
cd = [list(map(int, input().split())) for _ in range(n)]
g = [[] for _ in range(n)]
for u, v, a, b in uvab:
u, v = u - 1, v - 1
g[u].append([v, a, b])
g[v].append([u, a, b])
# 「現在いる頂点、現在持っている銀貨枚数」を頂点とし、ダイクストラ法でとく。
from heapq import heappop, heappush
inf = float("inf")
maxs = 50 * m
ans = [[inf] * (maxs + 1) for _ in range(n)]
s = min(s, maxs)
todo = [[0, 0, s]]
ans[0][s] = 0
while todo:
t, v, ss = heappop(todo)
if ans[v][ss] < t:
continue
for nv, na, nb in g[v]:
if na > ss:
continue
if ans[nv][ss - na] > t + nb:
heappush(todo, [t + nb, nv, ss - na])
ans[nv][ss - na] = t + nb
c, d = cd[v]
nss = min(ss + c, maxs)
if ans[v][nss] > t + d:
heappush(todo, [t + d, v, nss])
ans[v][nss] = t + d
for i in range(1, n):
print((min(ans[i])))
| n, m, s = list(map(int, input().split()))
uvab = [list(map(int, input().split())) for _ in range(m)]
cd = [list(map(int, input().split())) for _ in range(n)]
g = [[] for _ in range(n)]
maxs = 0
for u, v, a, b in uvab:
u, v = u - 1, v - 1
g[u].append([v, a, b])
g[v].append([u, a, b])
maxs += a
# 「現在いる頂点、現在持っている銀貨枚数」を頂点とし、ダイクストラ法でとく。
from heapq import heappop, heappush
inf = float("inf")
ans = [[inf] * (maxs + 1) for _ in range(n)]
s = min(s, maxs)
todo = [[0, 0, s]]
ans[0][s] = 0
while todo:
t, v, ss = heappop(todo)
if ans[v][ss] < t:
continue
for nv, na, nb in g[v]:
if na > ss:
continue
if ans[nv][ss - na] > t + nb:
heappush(todo, [t + nb, nv, ss - na])
ans[nv][ss - na] = t + nb
c, d = cd[v]
nss = min(ss + c, maxs)
if ans[v][nss] > t + d:
heappush(todo, [t + d, v, nss])
ans[v][nss] = t + d
for i in range(1, n):
print((min(ans[i])))
| false | 5.882353 | [
"+maxs = 0",
"+ maxs += a",
"-maxs = 50 * m"
]
| false | 0.047771 | 0.037419 | 1.276657 | [
"s746947001",
"s691133400"
]
|
u620755587 | p04034 | python | s136353000 | s710975144 | 602 | 389 | 63,960 | 12,540 | Accepted | Accepted | 35.38 | # coding: utf-8
# Your code here!s = input()
n, m = list(map(int, input().split()))
x = []
y = []
for i in range(m):
xi, yi = list(map(int, input().split()))
x.append(xi)
y.append(yi)
boxes = [False]*n
boxes[0] = True
boxescnt = [1]*n
for i in range(m):
if boxes[x[i]-1] == True:
if boxescnt[x[i]-1] == 1:
boxes[x[i]-1] = False
boxes[y[i]-1] = True
boxescnt[x[i]-1] -= 1
boxescnt[y[i]-1] += 1
print((sum(boxes)))
| n, m = list(map(int, input().split()))
x = []
y = []
for i in range(m):
xi, yi = list(map(int, input().split()))
x.append(xi)
y.append(yi)
num = [1]*n
able = [False]*n
able[0] = True
for i in range(m):
if able[x[i]-1] == True:
able[y[i]-1] = True
num[x[i]-1] -= 1
num[y[i]-1] += 1
if num[x[i]-1] == 0:
able[x[i]-1] = False
print((sum(able))) | 20 | 18 | 470 | 388 | # coding: utf-8
# Your code here!s = input()
n, m = list(map(int, input().split()))
x = []
y = []
for i in range(m):
xi, yi = list(map(int, input().split()))
x.append(xi)
y.append(yi)
boxes = [False] * n
boxes[0] = True
boxescnt = [1] * n
for i in range(m):
if boxes[x[i] - 1] == True:
if boxescnt[x[i] - 1] == 1:
boxes[x[i] - 1] = False
boxes[y[i] - 1] = True
boxescnt[x[i] - 1] -= 1
boxescnt[y[i] - 1] += 1
print((sum(boxes)))
| n, m = list(map(int, input().split()))
x = []
y = []
for i in range(m):
xi, yi = list(map(int, input().split()))
x.append(xi)
y.append(yi)
num = [1] * n
able = [False] * n
able[0] = True
for i in range(m):
if able[x[i] - 1] == True:
able[y[i] - 1] = True
num[x[i] - 1] -= 1
num[y[i] - 1] += 1
if num[x[i] - 1] == 0:
able[x[i] - 1] = False
print((sum(able)))
| false | 10 | [
"-# coding: utf-8",
"-# Your code here!s = input()",
"-boxes = [False] * n",
"-boxes[0] = True",
"-boxescnt = [1] * n",
"+num = [1] * n",
"+able = [False] * n",
"+able[0] = True",
"- if boxes[x[i] - 1] == True:",
"- if boxescnt[x[i] - 1] == 1:",
"- boxes[x[i] - 1] = False",
"- boxes[y[i] - 1] = True",
"- boxescnt[x[i] - 1] -= 1",
"- boxescnt[y[i] - 1] += 1",
"-print((sum(boxes)))",
"+ if able[x[i] - 1] == True:",
"+ able[y[i] - 1] = True",
"+ num[x[i] - 1] -= 1",
"+ num[y[i] - 1] += 1",
"+ if num[x[i] - 1] == 0:",
"+ able[x[i] - 1] = False",
"+print((sum(able)))"
]
| false | 0.038532 | 0.043237 | 0.891177 | [
"s136353000",
"s710975144"
]
|
u077291787 | p02936 | python | s974085602 | s927462027 | 895 | 663 | 93,048 | 93,572 | Accepted | Accepted | 25.92 | # ABC138D - Ki
from collections import deque
def main():
# Ai (A[i][0]) may be not a parent of Bi (A[i][1])
global T, cnt
N, Q, *A = list(map(int, open(0).read().split()))
E, P = A[: (N - 1) * 2], A[(N - 1) * 2 :]
T = [[] for _ in range(N + 1)]
for v, u in zip(*[iter(E)] * 2):
T[v].append(u), T[u].append(v)
cnt = [0] * (N + 1)
for p, x in zip(*[iter(P)] * 2):
cnt[p] += x # increase vertex p by x
stack = deque([(1, -1)])
while stack:
v, p = stack.popleft()
x = cnt[v]
for u in T[v]:
if u != p:
cnt[u] += x
stack.append((u, v))
print((*cnt[1:]))
if __name__ == "__main__":
main() | # ABC138D - Ki
from collections import deque
def main():
N, Q, *X = list(map(int, open(0).read().split()))
AB, PX = X[: 2 * (N - 1)], X[2 * (N - 1) :]
tree, cnt = [[] for _ in range(N + 1)], [0] * (N + 1)
for a, b in zip(*[iter(AB)] * 2):
tree[a].append(b), tree[b].append(a)
for p, x in zip(*[iter(PX)] * 2):
cnt[p] += x
queue = deque([1])
is_searched = [False] * (N + 1)
is_searched[1] = True
while queue:
u = queue.popleft()
cur_cnt = cnt[u]
is_searched[u] = True
for v in tree[u]:
if is_searched[v]:
continue
cnt[v] += cur_cnt
queue.append(v)
print((" ".join(map(str, cnt[1:]))))
if __name__ == "__main__":
main()
| 28 | 32 | 737 | 792 | # ABC138D - Ki
from collections import deque
def main():
# Ai (A[i][0]) may be not a parent of Bi (A[i][1])
global T, cnt
N, Q, *A = list(map(int, open(0).read().split()))
E, P = A[: (N - 1) * 2], A[(N - 1) * 2 :]
T = [[] for _ in range(N + 1)]
for v, u in zip(*[iter(E)] * 2):
T[v].append(u), T[u].append(v)
cnt = [0] * (N + 1)
for p, x in zip(*[iter(P)] * 2):
cnt[p] += x # increase vertex p by x
stack = deque([(1, -1)])
while stack:
v, p = stack.popleft()
x = cnt[v]
for u in T[v]:
if u != p:
cnt[u] += x
stack.append((u, v))
print((*cnt[1:]))
if __name__ == "__main__":
main()
| # ABC138D - Ki
from collections import deque
def main():
N, Q, *X = list(map(int, open(0).read().split()))
AB, PX = X[: 2 * (N - 1)], X[2 * (N - 1) :]
tree, cnt = [[] for _ in range(N + 1)], [0] * (N + 1)
for a, b in zip(*[iter(AB)] * 2):
tree[a].append(b), tree[b].append(a)
for p, x in zip(*[iter(PX)] * 2):
cnt[p] += x
queue = deque([1])
is_searched = [False] * (N + 1)
is_searched[1] = True
while queue:
u = queue.popleft()
cur_cnt = cnt[u]
is_searched[u] = True
for v in tree[u]:
if is_searched[v]:
continue
cnt[v] += cur_cnt
queue.append(v)
print((" ".join(map(str, cnt[1:]))))
if __name__ == "__main__":
main()
| false | 12.5 | [
"- # Ai (A[i][0]) may be not a parent of Bi (A[i][1])",
"- global T, cnt",
"- N, Q, *A = list(map(int, open(0).read().split()))",
"- E, P = A[: (N - 1) * 2], A[(N - 1) * 2 :]",
"- T = [[] for _ in range(N + 1)]",
"- for v, u in zip(*[iter(E)] * 2):",
"- T[v].append(u), T[u].append(v)",
"- cnt = [0] * (N + 1)",
"- for p, x in zip(*[iter(P)] * 2):",
"- cnt[p] += x # increase vertex p by x",
"- stack = deque([(1, -1)])",
"- while stack:",
"- v, p = stack.popleft()",
"- x = cnt[v]",
"- for u in T[v]:",
"- if u != p:",
"- cnt[u] += x",
"- stack.append((u, v))",
"- print((*cnt[1:]))",
"+ N, Q, *X = list(map(int, open(0).read().split()))",
"+ AB, PX = X[: 2 * (N - 1)], X[2 * (N - 1) :]",
"+ tree, cnt = [[] for _ in range(N + 1)], [0] * (N + 1)",
"+ for a, b in zip(*[iter(AB)] * 2):",
"+ tree[a].append(b), tree[b].append(a)",
"+ for p, x in zip(*[iter(PX)] * 2):",
"+ cnt[p] += x",
"+ queue = deque([1])",
"+ is_searched = [False] * (N + 1)",
"+ is_searched[1] = True",
"+ while queue:",
"+ u = queue.popleft()",
"+ cur_cnt = cnt[u]",
"+ is_searched[u] = True",
"+ for v in tree[u]:",
"+ if is_searched[v]:",
"+ continue",
"+ cnt[v] += cur_cnt",
"+ queue.append(v)",
"+ print((\" \".join(map(str, cnt[1:]))))"
]
| false | 0.040472 | 0.007435 | 5.443392 | [
"s974085602",
"s927462027"
]
|
u686036872 | p03805 | python | s766405478 | s184342375 | 205 | 24 | 43,100 | 3,064 | Accepted | Accepted | 88.29 | import sys
sys.setrecursionlimit(10**7) #再帰関数の呼び出し制限
N, M = list(map(int, input().split()))
A = [[0]* N for _ in range(N)]
for i in range(M):
a, b = list(map(int, input().split()))
A[a-1][b-1] = 1
A[b-1][a-1] = 1
visited=[1]+[0]*(N-1)
def DFS(now, visited):
ans = 0
if not 0 in visited:
return 1
for i in range(N):
if A[now][i] == 0:
continue
if visited[i] == 1:
continue
visited[i] = 1
ans += DFS(i, visited)
visited[i] = 0
return ans
print((DFS(0, visited))) | N, M = list(map(int, input().split()))
G = [[] for i in range(N)]
for i in range(M):
a, b = list(map(int, input().split()))
G[a-1].append(b-1)
G[b-1].append(a-1)
visited = [0]*N
visited[0] = 1
def dfs(v, visited):
if 0 not in visited:
return 1
ans = 0
for i in G[v]:
if visited[i] == 0:
visited[i] = 1
ans += dfs(i, visited)
visited[i] = 0
return ans
print((dfs(0, visited))) | 23 | 25 | 568 | 471 | import sys
sys.setrecursionlimit(10**7) # 再帰関数の呼び出し制限
N, M = list(map(int, input().split()))
A = [[0] * N for _ in range(N)]
for i in range(M):
a, b = list(map(int, input().split()))
A[a - 1][b - 1] = 1
A[b - 1][a - 1] = 1
visited = [1] + [0] * (N - 1)
def DFS(now, visited):
ans = 0
if not 0 in visited:
return 1
for i in range(N):
if A[now][i] == 0:
continue
if visited[i] == 1:
continue
visited[i] = 1
ans += DFS(i, visited)
visited[i] = 0
return ans
print((DFS(0, visited)))
| N, M = list(map(int, input().split()))
G = [[] for i in range(N)]
for i in range(M):
a, b = list(map(int, input().split()))
G[a - 1].append(b - 1)
G[b - 1].append(a - 1)
visited = [0] * N
visited[0] = 1
def dfs(v, visited):
if 0 not in visited:
return 1
ans = 0
for i in G[v]:
if visited[i] == 0:
visited[i] = 1
ans += dfs(i, visited)
visited[i] = 0
return ans
print((dfs(0, visited)))
| false | 8 | [
"-import sys",
"-",
"-sys.setrecursionlimit(10**7) # 再帰関数の呼び出し制限",
"-A = [[0] * N for _ in range(N)]",
"+G = [[] for i in range(N)]",
"- A[a - 1][b - 1] = 1",
"- A[b - 1][a - 1] = 1",
"-visited = [1] + [0] * (N - 1)",
"+ G[a - 1].append(b - 1)",
"+ G[b - 1].append(a - 1)",
"+visited = [0] * N",
"+visited[0] = 1",
"-def DFS(now, visited):",
"+def dfs(v, visited):",
"+ if 0 not in visited:",
"+ return 1",
"- if not 0 in visited:",
"- return 1",
"- for i in range(N):",
"- if A[now][i] == 0:",
"- continue",
"- if visited[i] == 1:",
"- continue",
"- visited[i] = 1",
"- ans += DFS(i, visited)",
"- visited[i] = 0",
"+ for i in G[v]:",
"+ if visited[i] == 0:",
"+ visited[i] = 1",
"+ ans += dfs(i, visited)",
"+ visited[i] = 0",
"-print((DFS(0, visited)))",
"+print((dfs(0, visited)))"
]
| false | 0.047976 | 0.04808 | 0.997833 | [
"s766405478",
"s184342375"
]
|
u150984829 | p02262 | python | s168552027 | s594362418 | 18,250 | 10,200 | 53,384 | 53,516 | Accepted | Accepted | 44.11 | import sys
n = int(input())
A=list(map(int,sys.stdin))
cnt = 0
G = [int((3**i-1)/2)for i in range(30,0,-1)]
G = [v for v in G if v <= n]
def insertionSort(A, n, g):
global cnt
for i in range(g, n):
v = A[i]
j = i - g
while j >= 0 and A[j] > v:
A[j+g] = A[j]
j = j - g
cnt += 1
A[j+g] = v
for g in G:
insertionSort(A, n, g)
print(len(G))
print(*G)
print(cnt)
print(*A,sep='\n')
| import sys
n = int(input())
A=[int(e)for e in sys.stdin]
cnt = 0
G = [int((2.25**i-1)/1.25)for i in range(17,0,-1)]
G = [v for v in G if v <= n]
def insertionSort(A, n, g):
global cnt
for i in range(g, n):
v = A[i]
j = i - g
while j >= 0 and A[j] > v:
A[j+g] = A[j]
j = j - g
cnt += 1
A[j+g] = v
for g in G:
insertionSort(A, n, g)
print(len(G))
print(*G)
print(cnt)
print(*A,sep='\n')
| 22 | 22 | 478 | 486 | import sys
n = int(input())
A = list(map(int, sys.stdin))
cnt = 0
G = [int((3**i - 1) / 2) for i in range(30, 0, -1)]
G = [v for v in G if v <= n]
def insertionSort(A, n, g):
global cnt
for i in range(g, n):
v = A[i]
j = i - g
while j >= 0 and A[j] > v:
A[j + g] = A[j]
j = j - g
cnt += 1
A[j + g] = v
for g in G:
insertionSort(A, n, g)
print(len(G))
print(*G)
print(cnt)
print(*A, sep="\n")
| import sys
n = int(input())
A = [int(e) for e in sys.stdin]
cnt = 0
G = [int((2.25**i - 1) / 1.25) for i in range(17, 0, -1)]
G = [v for v in G if v <= n]
def insertionSort(A, n, g):
global cnt
for i in range(g, n):
v = A[i]
j = i - g
while j >= 0 and A[j] > v:
A[j + g] = A[j]
j = j - g
cnt += 1
A[j + g] = v
for g in G:
insertionSort(A, n, g)
print(len(G))
print(*G)
print(cnt)
print(*A, sep="\n")
| false | 0 | [
"-A = list(map(int, sys.stdin))",
"+A = [int(e) for e in sys.stdin]",
"-G = [int((3**i - 1) / 2) for i in range(30, 0, -1)]",
"+G = [int((2.25**i - 1) / 1.25) for i in range(17, 0, -1)]"
]
| false | 0.041201 | 0.042949 | 0.959292 | [
"s168552027",
"s594362418"
]
|
u496762077 | p02779 | python | s302300585 | s879623292 | 184 | 83 | 26,808 | 26,804 | Accepted | Accepted | 54.89 | n = int(eval(input()))
a = list(map(int,input().split()))
res = True
a.sort()
for i in range(1,n):
if a[i-1]==a[i]:
res = False
break
if res:
print("YES")
else:
print("NO") | n = int(eval(input()))
a = list(map(int,input().split()))
if len(set(a)) == n:
print("YES")
else:
print("NO") | 12 | 6 | 205 | 112 | n = int(eval(input()))
a = list(map(int, input().split()))
res = True
a.sort()
for i in range(1, n):
if a[i - 1] == a[i]:
res = False
break
if res:
print("YES")
else:
print("NO")
| n = int(eval(input()))
a = list(map(int, input().split()))
if len(set(a)) == n:
print("YES")
else:
print("NO")
| false | 50 | [
"-res = True",
"-a.sort()",
"-for i in range(1, n):",
"- if a[i - 1] == a[i]:",
"- res = False",
"- break",
"-if res:",
"+if len(set(a)) == n:"
]
| false | 0.113117 | 0.031054 | 3.642618 | [
"s302300585",
"s879623292"
]
|
u074294821 | p03945 | python | s551172183 | s758029144 | 63 | 49 | 13,556 | 13,224 | Accepted | Accepted | 22.22 | l = list(eval(input()))
n = len(l)
idx = 0
seg = []
while idx < n:
while idx < n-1 and l[idx] == l[idx+1]:
idx+=1
seg.append(idx)
idx+=1
print((len(seg)-1))
| l = list(eval(input()))
n = len(l)
seg = []
for i in range(n-1):
if l[i] != l[i+1]:
seg.append(i)
print((len(seg)))
| 11 | 8 | 180 | 128 | l = list(eval(input()))
n = len(l)
idx = 0
seg = []
while idx < n:
while idx < n - 1 and l[idx] == l[idx + 1]:
idx += 1
seg.append(idx)
idx += 1
print((len(seg) - 1))
| l = list(eval(input()))
n = len(l)
seg = []
for i in range(n - 1):
if l[i] != l[i + 1]:
seg.append(i)
print((len(seg)))
| false | 27.272727 | [
"-idx = 0",
"-while idx < n:",
"- while idx < n - 1 and l[idx] == l[idx + 1]:",
"- idx += 1",
"- seg.append(idx)",
"- idx += 1",
"-print((len(seg) - 1))",
"+for i in range(n - 1):",
"+ if l[i] != l[i + 1]:",
"+ seg.append(i)",
"+print((len(seg)))"
]
| false | 0.047217 | 0.101165 | 0.466731 | [
"s551172183",
"s758029144"
]
|
u858742833 | p03167 | python | s046154869 | s894760844 | 189 | 155 | 3,444 | 3,188 | Accepted | Accepted | 17.99 | import sys
readline = sys.stdin.buffer.readline
# ord('.') == 46
def main():
H, W = list(map(int, readline().split()))
a = readline()
k = a.find(b'#')
if k == -1:
k = W
v = [1] * k + [0] * (W - k)
u = [0] * W
for _ in range(1, H):
a = readline()
u, v = v, u
v[0] = t = u[0] if a[0] == 46 else 0
for j, uu, aa in zip(list(range(1, W)), u[1:], a[1:]):
v[j] = t = uu + t if aa == 46 else 0
print((v[-1] % (10 ** 9 + 7)))
main()
| import sys
readline = sys.stdin.buffer.readline
# ord('.') == 46
def main():
H, W = list(map(int, readline().split()))
a = readline()
k = a.find(b'#')
if k == -1:
k = W
v = [1] * k + [0] * (W - k)
for m in range(1, H):
a = readline()
v[0] = t = v[0] if a[0] == 46 else 0
if m % 80 == 0:
for j, u, aa in zip(list(range(1, W)), v[1:], a[1:W]):
v[j] = t = (u + t) % 1000000007 if aa == 46 else 0
else:
for j, u, aa in zip(list(range(1, W)), v[1:], a[1:W]):
v[j] = t = (u + t) if aa == 46 else 0
print((v[-1] % 1000000007))
main()
| 23 | 25 | 521 | 659 | import sys
readline = sys.stdin.buffer.readline
# ord('.') == 46
def main():
H, W = list(map(int, readline().split()))
a = readline()
k = a.find(b"#")
if k == -1:
k = W
v = [1] * k + [0] * (W - k)
u = [0] * W
for _ in range(1, H):
a = readline()
u, v = v, u
v[0] = t = u[0] if a[0] == 46 else 0
for j, uu, aa in zip(list(range(1, W)), u[1:], a[1:]):
v[j] = t = uu + t if aa == 46 else 0
print((v[-1] % (10**9 + 7)))
main()
| import sys
readline = sys.stdin.buffer.readline
# ord('.') == 46
def main():
H, W = list(map(int, readline().split()))
a = readline()
k = a.find(b"#")
if k == -1:
k = W
v = [1] * k + [0] * (W - k)
for m in range(1, H):
a = readline()
v[0] = t = v[0] if a[0] == 46 else 0
if m % 80 == 0:
for j, u, aa in zip(list(range(1, W)), v[1:], a[1:W]):
v[j] = t = (u + t) % 1000000007 if aa == 46 else 0
else:
for j, u, aa in zip(list(range(1, W)), v[1:], a[1:W]):
v[j] = t = (u + t) if aa == 46 else 0
print((v[-1] % 1000000007))
main()
| false | 8 | [
"- u = [0] * W",
"- for _ in range(1, H):",
"+ for m in range(1, H):",
"- u, v = v, u",
"- v[0] = t = u[0] if a[0] == 46 else 0",
"- for j, uu, aa in zip(list(range(1, W)), u[1:], a[1:]):",
"- v[j] = t = uu + t if aa == 46 else 0",
"- print((v[-1] % (10**9 + 7)))",
"+ v[0] = t = v[0] if a[0] == 46 else 0",
"+ if m % 80 == 0:",
"+ for j, u, aa in zip(list(range(1, W)), v[1:], a[1:W]):",
"+ v[j] = t = (u + t) % 1000000007 if aa == 46 else 0",
"+ else:",
"+ for j, u, aa in zip(list(range(1, W)), v[1:], a[1:W]):",
"+ v[j] = t = (u + t) if aa == 46 else 0",
"+ print((v[-1] % 1000000007))"
]
| false | 0.049744 | 0.044316 | 1.122491 | [
"s046154869",
"s894760844"
]
|
u332906195 | p02912 | python | s765126487 | s349519230 | 182 | 160 | 14,380 | 14,380 | Accepted | Accepted | 12.09 | from math import ceil
import heapq
N, M = list(map(int, input().split()))
tmpA = list(map(int, input().split()))
A = [-a for a in tmpA]
heapq.heapify(A)
for _ in range(M):
a = heapq.heappop(A)
heapq.heappush(A, ceil(a / 2))
print((-sum(A)))
| from math import ceil
import heapq
N, M = list(map(int, input().split()))
A = [-int(a) for a in input().split()]
heapq.heapify(A)
for _ in range(M):
a = heapq.heappop(A)
heapq.heappush(A, ceil(a / 2))
print((-sum(A)))
| 13 | 12 | 256 | 232 | from math import ceil
import heapq
N, M = list(map(int, input().split()))
tmpA = list(map(int, input().split()))
A = [-a for a in tmpA]
heapq.heapify(A)
for _ in range(M):
a = heapq.heappop(A)
heapq.heappush(A, ceil(a / 2))
print((-sum(A)))
| from math import ceil
import heapq
N, M = list(map(int, input().split()))
A = [-int(a) for a in input().split()]
heapq.heapify(A)
for _ in range(M):
a = heapq.heappop(A)
heapq.heappush(A, ceil(a / 2))
print((-sum(A)))
| false | 7.692308 | [
"-tmpA = list(map(int, input().split()))",
"-A = [-a for a in tmpA]",
"+A = [-int(a) for a in input().split()]"
]
| false | 0.054532 | 0.060918 | 0.895167 | [
"s765126487",
"s349519230"
]
|
u332385682 | p03715 | python | s450486404 | s906429646 | 379 | 19 | 3,064 | 3,064 | Accepted | Accepted | 94.99 | import sys
inf = 1<<60
ans = inf
def solve():
H, W = list(map(int, input().split()))
calc(H, W)
calc(W, H)
print(ans)
def calc(H, W):
global ans
for a in range(1, W):
s0 = a * H
s1 = H * ((W - a + 1) // 2)
s2 = H * ((W - a) // 2)
ans = min(ans, max(s0, s1, s2) - min(s0, s1, s2))
s1 = (W - a) * ((H + 1) // 2)
s2 = (W - a) * (H // 2)
ans = min(ans, max(s0, s1, s2) - min(s0, s1, s2))
if __name__ == '__main__':
solve() | import sys
inf = 1<<60
ans = inf
def solve():
H, W = list(map(int, input().split()))
calc(H, W)
calc(W, H)
print(ans)
def calc(H, W):
global ans
x = W // 3
s0 = x * H
s1 = H * ((W - x + 1) // 2)
s2 = H * ((W - x) // 2)
ans = min(ans, max(s0, s1, s2) - min(s0, s1, s2))
s1 = (W - x) * ((H + 1) // 2)
s2 = (W - x) * (H // 2)
ans = min(ans, max(s0, s1, s2) - min(s0, s1, s2))
x = (W + 2) // 3
s0 = x * H
s1 = H * ((W - x + 1) // 2)
s2 = H * ((W - x) // 2)
ans = min(ans, max(s0, s1, s2) - min(s0, s1, s2))
s1 = (W - x) * ((H + 1) // 2)
s2 = (W - x) * (H // 2)
ans = min(ans, max(s0, s1, s2) - min(s0, s1, s2))
if __name__ == '__main__':
solve() | 29 | 43 | 534 | 784 | import sys
inf = 1 << 60
ans = inf
def solve():
H, W = list(map(int, input().split()))
calc(H, W)
calc(W, H)
print(ans)
def calc(H, W):
global ans
for a in range(1, W):
s0 = a * H
s1 = H * ((W - a + 1) // 2)
s2 = H * ((W - a) // 2)
ans = min(ans, max(s0, s1, s2) - min(s0, s1, s2))
s1 = (W - a) * ((H + 1) // 2)
s2 = (W - a) * (H // 2)
ans = min(ans, max(s0, s1, s2) - min(s0, s1, s2))
if __name__ == "__main__":
solve()
| import sys
inf = 1 << 60
ans = inf
def solve():
H, W = list(map(int, input().split()))
calc(H, W)
calc(W, H)
print(ans)
def calc(H, W):
global ans
x = W // 3
s0 = x * H
s1 = H * ((W - x + 1) // 2)
s2 = H * ((W - x) // 2)
ans = min(ans, max(s0, s1, s2) - min(s0, s1, s2))
s1 = (W - x) * ((H + 1) // 2)
s2 = (W - x) * (H // 2)
ans = min(ans, max(s0, s1, s2) - min(s0, s1, s2))
x = (W + 2) // 3
s0 = x * H
s1 = H * ((W - x + 1) // 2)
s2 = H * ((W - x) // 2)
ans = min(ans, max(s0, s1, s2) - min(s0, s1, s2))
s1 = (W - x) * ((H + 1) // 2)
s2 = (W - x) * (H // 2)
ans = min(ans, max(s0, s1, s2) - min(s0, s1, s2))
if __name__ == "__main__":
solve()
| false | 32.55814 | [
"- for a in range(1, W):",
"- s0 = a * H",
"- s1 = H * ((W - a + 1) // 2)",
"- s2 = H * ((W - a) // 2)",
"- ans = min(ans, max(s0, s1, s2) - min(s0, s1, s2))",
"- s1 = (W - a) * ((H + 1) // 2)",
"- s2 = (W - a) * (H // 2)",
"- ans = min(ans, max(s0, s1, s2) - min(s0, s1, s2))",
"+ x = W // 3",
"+ s0 = x * H",
"+ s1 = H * ((W - x + 1) // 2)",
"+ s2 = H * ((W - x) // 2)",
"+ ans = min(ans, max(s0, s1, s2) - min(s0, s1, s2))",
"+ s1 = (W - x) * ((H + 1) // 2)",
"+ s2 = (W - x) * (H // 2)",
"+ ans = min(ans, max(s0, s1, s2) - min(s0, s1, s2))",
"+ x = (W + 2) // 3",
"+ s0 = x * H",
"+ s1 = H * ((W - x + 1) // 2)",
"+ s2 = H * ((W - x) // 2)",
"+ ans = min(ans, max(s0, s1, s2) - min(s0, s1, s2))",
"+ s1 = (W - x) * ((H + 1) // 2)",
"+ s2 = (W - x) * (H // 2)",
"+ ans = min(ans, max(s0, s1, s2) - min(s0, s1, s2))"
]
| false | 0.110429 | 0.038673 | 2.855454 | [
"s450486404",
"s906429646"
]
|
u325282913 | p03805 | python | s548759777 | s678336804 | 214 | 34 | 41,692 | 9,352 | Accepted | Accepted | 84.11 | N, M = list(map(int, input().split()))
edge = [[] for _ in range(N)]
for i in range(M):
a, b = list(map(int, input().split()))
edge[a-1].append(b-1)
edge[b-1].append(a-1)
def dfs(start,route):
route.append(start)
if len(route) == N:
route.remove(start)
return 1
res = 0
for i in edge[start]:
if i not in route:
res += dfs(i,route)
route.remove(start)
return res
print((dfs(0,[]))) | import copy
import sys
sys.setrecursionlimit(10**7)
N, M = list(map(int, input().split()))
edges = [[] for _ in range(N)]
for _ in range(M):
a, b = list(map(int, input().split()))
edges[a - 1].append(b - 1)
edges[b - 1].append(a - 1)
ans = 0
def dfs(start,path):
next_path = copy.copy(path)
global ans
next_path.append(start)
if len(next_path) == N:
ans += 1
return
for i in edges[start]:
if i not in next_path:
dfs(i,next_path)
dfs(0,[])
print(ans) | 18 | 22 | 455 | 526 | N, M = list(map(int, input().split()))
edge = [[] for _ in range(N)]
for i in range(M):
a, b = list(map(int, input().split()))
edge[a - 1].append(b - 1)
edge[b - 1].append(a - 1)
def dfs(start, route):
route.append(start)
if len(route) == N:
route.remove(start)
return 1
res = 0
for i in edge[start]:
if i not in route:
res += dfs(i, route)
route.remove(start)
return res
print((dfs(0, [])))
| import copy
import sys
sys.setrecursionlimit(10**7)
N, M = list(map(int, input().split()))
edges = [[] for _ in range(N)]
for _ in range(M):
a, b = list(map(int, input().split()))
edges[a - 1].append(b - 1)
edges[b - 1].append(a - 1)
ans = 0
def dfs(start, path):
next_path = copy.copy(path)
global ans
next_path.append(start)
if len(next_path) == N:
ans += 1
return
for i in edges[start]:
if i not in next_path:
dfs(i, next_path)
dfs(0, [])
print(ans)
| false | 18.181818 | [
"+import copy",
"+import sys",
"+",
"+sys.setrecursionlimit(10**7)",
"-edge = [[] for _ in range(N)]",
"-for i in range(M):",
"+edges = [[] for _ in range(N)]",
"+for _ in range(M):",
"- edge[a - 1].append(b - 1)",
"- edge[b - 1].append(a - 1)",
"+ edges[a - 1].append(b - 1)",
"+ edges[b - 1].append(a - 1)",
"+ans = 0",
"-def dfs(start, route):",
"- route.append(start)",
"- if len(route) == N:",
"- route.remove(start)",
"- return 1",
"- res = 0",
"- for i in edge[start]:",
"- if i not in route:",
"- res += dfs(i, route)",
"- route.remove(start)",
"- return res",
"+def dfs(start, path):",
"+ next_path = copy.copy(path)",
"+ global ans",
"+ next_path.append(start)",
"+ if len(next_path) == N:",
"+ ans += 1",
"+ return",
"+ for i in edges[start]:",
"+ if i not in next_path:",
"+ dfs(i, next_path)",
"-print((dfs(0, [])))",
"+dfs(0, [])",
"+print(ans)"
]
| false | 0.037709 | 0.235884 | 0.159863 | [
"s548759777",
"s678336804"
]
|
u017810624 | p02875 | python | s279269939 | s775117331 | 3,196 | 1,709 | 481,456 | 132,500 | Accepted | Accepted | 46.53 | def cmb(n,r,mod):
if r<0 or r>n:
return 0
r=min(r,n-r)
return g1[n]*g2[r]*g2[n-r]%mod
n=int(eval(input()))
mod=998244353
g1=[1,1]
g2=[1,1]
inverse=[0,1]
for i in range(2,n+1):
g1.append((g1[-1]*i)%mod)
inverse.append((-inverse[mod%i]*(mod//i))%mod)
g2.append((g2[-1]*inverse[-1])%mod)
a=0
b=1
for i in range(n,n//2,-1):
a+=cmb(n,i,mod)*b
a%=mod
b*=2
b%=mod
ans=(pow(3,n,mod)-2*a)%mod
print(((ans+mod)%mod)) | n=int(eval(input()));l=[0,1];a=0;b=c=1;p=998244353
for i in range(2,n//2+1):
l+=[l[p%i]*(p-int(p/i))%p]
for i in range(n,n//2,-1):
a+=b*c%p;b=2*b%p;c=c*i*l[n+1-i]%p
print(((pow(3,n,p)-2*a+p)%p)) | 27 | 6 | 454 | 193 | def cmb(n, r, mod):
if r < 0 or r > n:
return 0
r = min(r, n - r)
return g1[n] * g2[r] * g2[n - r] % mod
n = int(eval(input()))
mod = 998244353
g1 = [1, 1]
g2 = [1, 1]
inverse = [0, 1]
for i in range(2, n + 1):
g1.append((g1[-1] * i) % mod)
inverse.append((-inverse[mod % i] * (mod // i)) % mod)
g2.append((g2[-1] * inverse[-1]) % mod)
a = 0
b = 1
for i in range(n, n // 2, -1):
a += cmb(n, i, mod) * b
a %= mod
b *= 2
b %= mod
ans = (pow(3, n, mod) - 2 * a) % mod
print(((ans + mod) % mod))
| n = int(eval(input()))
l = [0, 1]
a = 0
b = c = 1
p = 998244353
for i in range(2, n // 2 + 1):
l += [l[p % i] * (p - int(p / i)) % p]
for i in range(n, n // 2, -1):
a += b * c % p
b = 2 * b % p
c = c * i * l[n + 1 - i] % p
print(((pow(3, n, p) - 2 * a + p) % p))
| false | 77.777778 | [
"-def cmb(n, r, mod):",
"- if r < 0 or r > n:",
"- return 0",
"- r = min(r, n - r)",
"- return g1[n] * g2[r] * g2[n - r] % mod",
"-",
"-",
"-mod = 998244353",
"-g1 = [1, 1]",
"-g2 = [1, 1]",
"-inverse = [0, 1]",
"-for i in range(2, n + 1):",
"- g1.append((g1[-1] * i) % mod)",
"- inverse.append((-inverse[mod % i] * (mod // i)) % mod)",
"- g2.append((g2[-1] * inverse[-1]) % mod)",
"+l = [0, 1]",
"-b = 1",
"+b = c = 1",
"+p = 998244353",
"+for i in range(2, n // 2 + 1):",
"+ l += [l[p % i] * (p - int(p / i)) % p]",
"- a += cmb(n, i, mod) * b",
"- a %= mod",
"- b *= 2",
"- b %= mod",
"-ans = (pow(3, n, mod) - 2 * a) % mod",
"-print(((ans + mod) % mod))",
"+ a += b * c % p",
"+ b = 2 * b % p",
"+ c = c * i * l[n + 1 - i] % p",
"+print(((pow(3, n, p) - 2 * a + p) % p))"
]
| false | 0.601436 | 0.429367 | 1.400748 | [
"s279269939",
"s775117331"
]
|
u608088992 | p03435 | python | s200471881 | s689394213 | 597 | 17 | 3,064 | 3,064 | Accepted | Accepted | 97.15 | import sys
def solve():
input = sys.stdin.readline
C = [[int(c) for c in input().split()] for _ in range(3)]
possible = False
for i in range(101):
for j in range(101):
for k in range(101):
a11 = C[0][0] - i
a12 = C[0][1] - j
a13 = C[0][2] - k
a21 = C[1][0] - i
a22 = C[1][1] - j
a23 = C[1][2] - k
a31 = C[2][0] - i
a32 = C[2][1] - j
a33 = C[2][2] - k
if a11 == a12 == a13 and a21 == a22 == a23 and a31 == a32 == a33:
possible = True
break
if possible: break
if possible: break
print(("Yes" if possible else "No"))
return 0
if __name__ == "__main__":
solve() | def solve():
C = [[int(c) for c in input().split()] for _ in range(3)]
diffr1 = C[0][1] - C[0][0]
diffr2 = C[0][2] - C[0][1]
diffc1 = C[1][0] - C[0][0]
diffc2 = C[2][0] - C[1][0]
if C[1][1] - C[1][0] == C[2][1] - C[2][0] == diffr1:
if C[1][2] - C[1][1] == C[2][2] - C[2][1] == diffr2:
if C[1][1] - C[0][1] == C[1][2] - C[0][2] == diffc1:
if C[2][1] - C[1][1] == C[2][2] - C[1][2] == diffc2:
return "Yes"
return "No"
if __name__ == "__main__":
print((solve())) | 29 | 15 | 854 | 561 | import sys
def solve():
input = sys.stdin.readline
C = [[int(c) for c in input().split()] for _ in range(3)]
possible = False
for i in range(101):
for j in range(101):
for k in range(101):
a11 = C[0][0] - i
a12 = C[0][1] - j
a13 = C[0][2] - k
a21 = C[1][0] - i
a22 = C[1][1] - j
a23 = C[1][2] - k
a31 = C[2][0] - i
a32 = C[2][1] - j
a33 = C[2][2] - k
if a11 == a12 == a13 and a21 == a22 == a23 and a31 == a32 == a33:
possible = True
break
if possible:
break
if possible:
break
print(("Yes" if possible else "No"))
return 0
if __name__ == "__main__":
solve()
| def solve():
C = [[int(c) for c in input().split()] for _ in range(3)]
diffr1 = C[0][1] - C[0][0]
diffr2 = C[0][2] - C[0][1]
diffc1 = C[1][0] - C[0][0]
diffc2 = C[2][0] - C[1][0]
if C[1][1] - C[1][0] == C[2][1] - C[2][0] == diffr1:
if C[1][2] - C[1][1] == C[2][2] - C[2][1] == diffr2:
if C[1][1] - C[0][1] == C[1][2] - C[0][2] == diffc1:
if C[2][1] - C[1][1] == C[2][2] - C[1][2] == diffc2:
return "Yes"
return "No"
if __name__ == "__main__":
print((solve()))
| false | 48.275862 | [
"-import sys",
"-",
"-",
"- input = sys.stdin.readline",
"- possible = False",
"- for i in range(101):",
"- for j in range(101):",
"- for k in range(101):",
"- a11 = C[0][0] - i",
"- a12 = C[0][1] - j",
"- a13 = C[0][2] - k",
"- a21 = C[1][0] - i",
"- a22 = C[1][1] - j",
"- a23 = C[1][2] - k",
"- a31 = C[2][0] - i",
"- a32 = C[2][1] - j",
"- a33 = C[2][2] - k",
"- if a11 == a12 == a13 and a21 == a22 == a23 and a31 == a32 == a33:",
"- possible = True",
"- break",
"- if possible:",
"- break",
"- if possible:",
"- break",
"- print((\"Yes\" if possible else \"No\"))",
"- return 0",
"+ diffr1 = C[0][1] - C[0][0]",
"+ diffr2 = C[0][2] - C[0][1]",
"+ diffc1 = C[1][0] - C[0][0]",
"+ diffc2 = C[2][0] - C[1][0]",
"+ if C[1][1] - C[1][0] == C[2][1] - C[2][0] == diffr1:",
"+ if C[1][2] - C[1][1] == C[2][2] - C[2][1] == diffr2:",
"+ if C[1][1] - C[0][1] == C[1][2] - C[0][2] == diffc1:",
"+ if C[2][1] - C[1][1] == C[2][2] - C[1][2] == diffc2:",
"+ return \"Yes\"",
"+ return \"No\"",
"- solve()",
"+ print((solve()))"
]
| false | 0.691265 | 0.036796 | 18.786561 | [
"s200471881",
"s689394213"
]
|
u852613820 | p02947 | python | s129175028 | s343702193 | 393 | 222 | 17,892 | 17,848 | Accepted | Accepted | 43.51 | # coding: utf-8
# Your code here!
N = int(eval(input()))
sd = {}
ans = 0
for _ in range(N):
inp = eval(input())
si = ''.join(sorted(inp))
if not si in sd:
sd[si] = 1
else:
ans += sd[si]
sd[si] += 1
print(ans)
| # coding: utf-8
import sys
input = sys.stdin.readline
def main():
N = int(eval(input()))
sd = {}
ans = 0
for _ in range(N):
si = ''.join(sorted(input().strip()))
if not si in sd:
sd[si] = 1
else:
ans += sd[si]
sd[si] += 1
print(ans)
if __name__ == '__main__':
main() | 18 | 19 | 262 | 368 | # coding: utf-8
# Your code here!
N = int(eval(input()))
sd = {}
ans = 0
for _ in range(N):
inp = eval(input())
si = "".join(sorted(inp))
if not si in sd:
sd[si] = 1
else:
ans += sd[si]
sd[si] += 1
print(ans)
| # coding: utf-8
import sys
input = sys.stdin.readline
def main():
N = int(eval(input()))
sd = {}
ans = 0
for _ in range(N):
si = "".join(sorted(input().strip()))
if not si in sd:
sd[si] = 1
else:
ans += sd[si]
sd[si] += 1
print(ans)
if __name__ == "__main__":
main()
| false | 5.263158 | [
"-# Your code here!",
"-N = int(eval(input()))",
"-sd = {}",
"-ans = 0",
"-for _ in range(N):",
"- inp = eval(input())",
"- si = \"\".join(sorted(inp))",
"- if not si in sd:",
"- sd[si] = 1",
"- else:",
"- ans += sd[si]",
"- sd[si] += 1",
"-print(ans)",
"+import sys",
"+",
"+input = sys.stdin.readline",
"+",
"+",
"+def main():",
"+ N = int(eval(input()))",
"+ sd = {}",
"+ ans = 0",
"+ for _ in range(N):",
"+ si = \"\".join(sorted(input().strip()))",
"+ if not si in sd:",
"+ sd[si] = 1",
"+ else:",
"+ ans += sd[si]",
"+ sd[si] += 1",
"+ print(ans)",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
]
| false | 0.046552 | 0.043293 | 1.075296 | [
"s129175028",
"s343702193"
]
|
u072717685 | p03416 | python | s295519632 | s231637989 | 50 | 45 | 9,164 | 9,180 | Accepted | Accepted | 10 | import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
def main():
a, b = list(map(int, input().split()))
r = 0
for i1 in range(a, b + 1):
stri1 = str(i1)
r += stri1 == stri1[::-1]
print(r)
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
def main():
a, b = list(map(int, input().split()))
r = 0
for i1 in range(a, b + 1):
c1 = i1 // 10000 == i1 % 10
c2 = ((i1 // 1000) % 10) == ((i1//10)%10)
r += c1 and c2
print(r)
if __name__ == '__main__':
main() | 14 | 14 | 279 | 328 | import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
def main():
a, b = list(map(int, input().split()))
r = 0
for i1 in range(a, b + 1):
stri1 = str(i1)
r += stri1 == stri1[::-1]
print(r)
if __name__ == "__main__":
main()
| import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
def main():
a, b = list(map(int, input().split()))
r = 0
for i1 in range(a, b + 1):
c1 = i1 // 10000 == i1 % 10
c2 = ((i1 // 1000) % 10) == ((i1 // 10) % 10)
r += c1 and c2
print(r)
if __name__ == "__main__":
main()
| false | 0 | [
"- stri1 = str(i1)",
"- r += stri1 == stri1[::-1]",
"+ c1 = i1 // 10000 == i1 % 10",
"+ c2 = ((i1 // 1000) % 10) == ((i1 // 10) % 10)",
"+ r += c1 and c2"
]
| false | 0.040972 | 0.051176 | 0.800621 | [
"s295519632",
"s231637989"
]
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.