user_id
stringlengths 10
10
| problem_id
stringlengths 6
6
| language
stringclasses 1
value | submission_id_v0
stringlengths 10
10
| submission_id_v1
stringlengths 10
10
| cpu_time_v0
int64 10
38.3k
| cpu_time_v1
int64 0
24.7k
| memory_v0
int64 2.57k
1.02M
| memory_v1
int64 2.57k
869k
| status_v0
stringclasses 1
value | status_v1
stringclasses 1
value | improvement_frac
float64 7.51
100
| input
stringlengths 20
4.55k
| target
stringlengths 17
3.34k
| code_v0_loc
int64 1
148
| code_v1_loc
int64 1
184
| code_v0_num_chars
int64 13
4.55k
| code_v1_num_chars
int64 14
3.34k
| code_v0_no_empty_lines
stringlengths 21
6.88k
| code_v1_no_empty_lines
stringlengths 20
4.93k
| code_same
bool 1
class | relative_loc_diff_percent
float64 0
79.8
| diff
sequence | diff_only_import_comment
bool 1
class | measured_runtime_v0
float64 0.01
4.45
| measured_runtime_v1
float64 0.01
4.31
| runtime_lift
float64 0
359
| key
sequence |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
u847467233 | p02441 | python | s176442444 | s482967581 | 50 | 20 | 5,636 | 5,632 | Accepted | Accepted | 60 | # AOJ ITP2_3_C: Count
# Python3 2018.6.24 bal4u
n = int(eval(input()))
a = list(map(int, input().split()))
q = int(eval(input()))
for i in range(q):
b, e, k = list(map(int, input().split()))
s = a[b:e]
print((s.count(k)))
| # AOJ ITP2_3_C: Count
# Python3 2018.6.24 bal4u
n = int(eval(input()))
a = list(map(int, input().split()))
q = int(eval(input()))
for i in range(q):
b, e, k = list(map(int, input().split()))
print((a[b:e].count(k)))
| 10 | 9 | 215 | 207 | # AOJ ITP2_3_C: Count
# Python3 2018.6.24 bal4u
n = int(eval(input()))
a = list(map(int, input().split()))
q = int(eval(input()))
for i in range(q):
b, e, k = list(map(int, input().split()))
s = a[b:e]
print((s.count(k)))
| # AOJ ITP2_3_C: Count
# Python3 2018.6.24 bal4u
n = int(eval(input()))
a = list(map(int, input().split()))
q = int(eval(input()))
for i in range(q):
b, e, k = list(map(int, input().split()))
print((a[b:e].count(k)))
| false | 10 | [
"- s = a[b:e]",
"- print((s.count(k)))",
"+ print((a[b:e].count(k)))"
] | false | 0.044942 | 0.085396 | 0.526278 | [
"s176442444",
"s482967581"
] |
u614314290 | p02948 | python | s966874767 | s313266083 | 579 | 454 | 32,748 | 27,656 | Accepted | Accepted | 21.59 | import math, heapq
from operator import itemgetter as ig
from collections import defaultdict as dd
# 定数
INF = float("inf")
MOD = int(1e9 + 7)
# ヒープ
class heapque:
def __init__(self, *args):
self.que = []
for arg in args:
self.push(arg)
def push(self, v):
heapq.heappush(self.que, v)
def pop(self):
return heapq.heappop(self.que)
# 最大公約数 / 最小公倍数
def gcd(v1, v2):
if v2 == 0:
return v1
return gcd(v2, v1 % v2)
def lcm(v1, v2):
return (v1 // gcd(v1, v2)) * v2
# 二分探索
def bsr(a, v, lo=0, hi=None):
if hi == None:
hi = len(a) - 1
if hi < lo:
return lo
mi = (lo + hi) // 2
if v < a[mi]:
return bsr(a, v, lo, mi - 1)
else:
return bsr(a, v, mi + 1, hi)
# Union-Find木
class uft:
def __init__(self, n):
self.height = [1] * n
self.group = [-1] * n
def root(self, v):
if self.group[v] < 0:
return v
self.group[v] = self.root(self.group[v])
return self.group[v]
def size(self, v):
return - self.group[self.root(v)]
def merge(self, v1, v2):
v1, v2 = self.root(v1), self.root(v2)
if v1 == v2:
return
if self.height[v1] < self.height[v2]:
self.group[v2] += self.group[v1]
self.group[v1] = v2
self.height[v2] = max(self.height[v1] + 1, self.height[v2])
else:
self.group[v1] += self.group[v2]
self.group[v2] = v1
self.height[v1] = max(self.height[v1] , self.height[v2] + 1)
# グラフ
class graph:
def __init__(self, n):
self.n = n
self.graph = [[] for _ in range(n)]
def append(self, v1, v2, cost=1):
self.graph[v1].append((v2, cost))
# 最短経路：ダイクストラ法(Dijkstra's Algorithm)
def dks(self, v):
costs = [INF] * self.n
costs[v] = 0
done = [False] * self.n
heap = heapque((0, v))
while heap.que:
c_cost, c_index = heap.pop()
if done[c_index]:
continue
done[c_index] = True
for n_index, n_cost in self.graph[c_index]:
if c_cost + n_cost < costs[n_index]:
costs[n_index] = c_cost + n_cost
heap.push((costs[n_index], n_index))
return costs
def main():
N, M = list(map(int, input().split()))
AB = [list(map(int, input().split())) for _ in range(N)]
ab = sorted(AB)
heap = heapque()
v, i = 0, 0
for m in range(1, M + 1):
while i < N:
if ab[i][0] <= m:
heap.push(-ab[i][1])
i += 1
else:
break
if heap.que:
v += -heap.pop()
print(v)
main()
| import math, heapq
from operator import itemgetter as ig
from collections import defaultdict as dd
# 定数
INF = float("inf")
MOD = int(1e9 + 7)
# ヒープ
class heapque:
def __init__(self, *args):
self.que = []
for arg in args:
self.push(arg)
def push(self, v):
heapq.heappush(self.que, v)
def pop(self):
return heapq.heappop(self.que)
# 最大公約数 / 最小公倍数
def gcd(v1, v2):
if v2 == 0:
return v1
return gcd(v2, v1 % v2)
def lcm(v1, v2):
return (v1 // gcd(v1, v2)) * v2
# 二分探索
def bsr(a, v, lo=0, hi=None):
if hi == None:
hi = len(a) - 1
if hi < lo:
return lo
mi = (lo + hi) // 2
if v < a[mi]:
return bsr(a, v, lo, mi - 1)
else:
return bsr(a, v, mi + 1, hi)
# Union-Find木
class uft:
def __init__(self, n):
self.height = [1] * n
self.group = [-1] * n
def root(self, v):
if self.group[v] < 0:
return v
self.group[v] = self.root(self.group[v])
return self.group[v]
def size(self, v):
return - self.group[self.root(v)]
def merge(self, v1, v2):
v1, v2 = self.root(v1), self.root(v2)
if v1 == v2:
return
if self.height[v1] < self.height[v2]:
self.group[v2] += self.group[v1]
self.group[v1] = v2
self.height[v2] = max(self.height[v1] + 1, self.height[v2])
else:
self.group[v1] += self.group[v2]
self.group[v2] = v1
self.height[v1] = max(self.height[v1] , self.height[v2] + 1)
# グラフ
class graph:
def __init__(self, n):
self.n = n
self.graph = [[] for _ in range(n)]
def append(self, v1, v2, cost=1):
self.graph[v1].append((v2, cost))
# 最短経路：ダイクストラ法(Dijkstra's Algorithm)
def dks(self, v):
costs = [INF] * self.n
costs[v] = 0
done = [False] * self.n
heap = heapque((0, v))
while heap.que:
c_cost, c_index = heap.pop()
if done[c_index]:
continue
done[c_index] = True
for n_index, n_cost in self.graph[c_index]:
if c_cost + n_cost < costs[n_index]:
costs[n_index] = c_cost + n_cost
heap.push((costs[n_index], n_index))
return costs
def main():
N, M = list(map(int, input().split()))
ab = dd(list)
for _ in range(N):
a, b = list(map(int, input().split()))
ab[a].append(b)
heap = heapque()
v = 0
for m in range(1, M + 1):
if m in ab:
for b in ab[m]:
heap.push(-b)
if heap.que:
v += -heap.pop()
print(v)
main()
| 101 | 100 | 2,857 | 2,802 | import math, heapq
from operator import itemgetter as ig
from collections import defaultdict as dd
# 定数
INF = float("inf")
MOD = int(1e9 + 7)
# ヒープ
class heapque:
def __init__(self, *args):
self.que = []
for arg in args:
self.push(arg)
def push(self, v):
heapq.heappush(self.que, v)
def pop(self):
return heapq.heappop(self.que)
# 最大公約数 / 最小公倍数
def gcd(v1, v2):
if v2 == 0:
return v1
return gcd(v2, v1 % v2)
def lcm(v1, v2):
return (v1 // gcd(v1, v2)) * v2
# 二分探索
def bsr(a, v, lo=0, hi=None):
if hi == None:
hi = len(a) - 1
if hi < lo:
return lo
mi = (lo + hi) // 2
if v < a[mi]:
return bsr(a, v, lo, mi - 1)
else:
return bsr(a, v, mi + 1, hi)
# Union-Find木
class uft:
def __init__(self, n):
self.height = [1] * n
self.group = [-1] * n
def root(self, v):
if self.group[v] < 0:
return v
self.group[v] = self.root(self.group[v])
return self.group[v]
def size(self, v):
return -self.group[self.root(v)]
def merge(self, v1, v2):
v1, v2 = self.root(v1), self.root(v2)
if v1 == v2:
return
if self.height[v1] < self.height[v2]:
self.group[v2] += self.group[v1]
self.group[v1] = v2
self.height[v2] = max(self.height[v1] + 1, self.height[v2])
else:
self.group[v1] += self.group[v2]
self.group[v2] = v1
self.height[v1] = max(self.height[v1], self.height[v2] + 1)
# グラフ
class graph:
def __init__(self, n):
self.n = n
self.graph = [[] for _ in range(n)]
def append(self, v1, v2, cost=1):
self.graph[v1].append((v2, cost))
# 最短経路：ダイクストラ法(Dijkstra's Algorithm)
def dks(self, v):
costs = [INF] * self.n
costs[v] = 0
done = [False] * self.n
heap = heapque((0, v))
while heap.que:
c_cost, c_index = heap.pop()
if done[c_index]:
continue
done[c_index] = True
for n_index, n_cost in self.graph[c_index]:
if c_cost + n_cost < costs[n_index]:
costs[n_index] = c_cost + n_cost
heap.push((costs[n_index], n_index))
return costs
def main():
N, M = list(map(int, input().split()))
AB = [list(map(int, input().split())) for _ in range(N)]
ab = sorted(AB)
heap = heapque()
v, i = 0, 0
for m in range(1, M + 1):
while i < N:
if ab[i][0] <= m:
heap.push(-ab[i][1])
i += 1
else:
break
if heap.que:
v += -heap.pop()
print(v)
main()
| import math, heapq
from operator import itemgetter as ig
from collections import defaultdict as dd
# 定数
INF = float("inf")
MOD = int(1e9 + 7)
# ヒープ
class heapque:
def __init__(self, *args):
self.que = []
for arg in args:
self.push(arg)
def push(self, v):
heapq.heappush(self.que, v)
def pop(self):
return heapq.heappop(self.que)
# 最大公約数 / 最小公倍数
def gcd(v1, v2):
if v2 == 0:
return v1
return gcd(v2, v1 % v2)
def lcm(v1, v2):
return (v1 // gcd(v1, v2)) * v2
# 二分探索
def bsr(a, v, lo=0, hi=None):
if hi == None:
hi = len(a) - 1
if hi < lo:
return lo
mi = (lo + hi) // 2
if v < a[mi]:
return bsr(a, v, lo, mi - 1)
else:
return bsr(a, v, mi + 1, hi)
# Union-Find木
class uft:
def __init__(self, n):
self.height = [1] * n
self.group = [-1] * n
def root(self, v):
if self.group[v] < 0:
return v
self.group[v] = self.root(self.group[v])
return self.group[v]
def size(self, v):
return -self.group[self.root(v)]
def merge(self, v1, v2):
v1, v2 = self.root(v1), self.root(v2)
if v1 == v2:
return
if self.height[v1] < self.height[v2]:
self.group[v2] += self.group[v1]
self.group[v1] = v2
self.height[v2] = max(self.height[v1] + 1, self.height[v2])
else:
self.group[v1] += self.group[v2]
self.group[v2] = v1
self.height[v1] = max(self.height[v1], self.height[v2] + 1)
# グラフ
class graph:
def __init__(self, n):
self.n = n
self.graph = [[] for _ in range(n)]
def append(self, v1, v2, cost=1):
self.graph[v1].append((v2, cost))
# 最短経路：ダイクストラ法(Dijkstra's Algorithm)
def dks(self, v):
costs = [INF] * self.n
costs[v] = 0
done = [False] * self.n
heap = heapque((0, v))
while heap.que:
c_cost, c_index = heap.pop()
if done[c_index]:
continue
done[c_index] = True
for n_index, n_cost in self.graph[c_index]:
if c_cost + n_cost < costs[n_index]:
costs[n_index] = c_cost + n_cost
heap.push((costs[n_index], n_index))
return costs
def main():
N, M = list(map(int, input().split()))
ab = dd(list)
for _ in range(N):
a, b = list(map(int, input().split()))
ab[a].append(b)
heap = heapque()
v = 0
for m in range(1, M + 1):
if m in ab:
for b in ab[m]:
heap.push(-b)
if heap.que:
v += -heap.pop()
print(v)
main()
| false | 0.990099 | [
"- AB = [list(map(int, input().split())) for _ in range(N)]",
"- ab = sorted(AB)",
"+ ab = dd(list)",
"+ for _ in range(N):",
"+ a, b = list(map(int, input().split()))",
"+ ab[a].append(b)",
"- v, i = 0, 0",
"+ v = 0",
"- while i < N:",
"- if ab[i][0] <= m:",
"- heap.push(-ab[i][1])",
"- i += 1",
"- else:",
"- break",
"+ if m in ab:",
"+ for b in ab[m]:",
"+ heap.push(-b)"
] | false | 0.045674 | 0.06252 | 0.730549 | [
"s966874767",
"s313266083"
] |
u320567105 | p03112 | python | s696873180 | s275639128 | 1,816 | 1,033 | 113,724 | 17,780 | Accepted | Accepted | 43.12 | A,B,Q=list(map(int,input().split()))
s=[0]*(A+2)
t=[0]*(B+2)
X=[0]*Q
s[0] = -float('inf')
s[A+1] = float('inf')
t[0] = -float('inf')
t[B+1] = float('inf')
for i in range(1,A+1):
s[i] = int(eval(input()))
for i in range(1,B+1):
t[i] = int(eval(input()))
for i in range(Q):
X[i] = int(eval(input()))
import bisect
for x in X:
s_i = bisect.bisect_left(s,x)
t_i = bisect.bisect_left(t,x)
s_l = abs(s[s_i-1]-x)
s_r = s[s_i]-x
t_l = abs(t[t_i-1]-x)
t_r = t[t_i]-x
ans = min([max(s_l,t_l),s_l+t_r+min(s_l,t_r),s_r+t_l+min(s_r,t_l),max(s_r,t_r)])
print(ans)
| ri = lambda: int(eval(input()))
rl = lambda: list(map(int,input().split()))
A,B,Q=rl()
s=[0]*(A+2)
t=[0]*(B+2)
X=[0]*Q
for i in range(1,A+1):
s[i]=ri()
s[0],s[A+1]=-float('inf'),float('inf')
s.sort()
for i in range(1,B+1):
t[i]=ri()
t[0],t[B+1]=-float('inf'),float('inf')
t.sort()
for i in range(Q):
X[i]=ri()
import bisect
for x in X:
s_i = bisect.bisect_left(s,x)
t_i = bisect.bisect_left(t,x)
s_l = x-s[s_i-1]
s_r = s[s_i]-x
t_l = x-t[t_i-1]
t_r = t[t_i]-x
ans = min(
[max(s_l,t_l), s_l+t_r+min(s_l,t_r), s_r+t_l+min(s_r,t_l), max(s_r,t_r)]
)
print(ans) | 29 | 30 | 609 | 637 | A, B, Q = list(map(int, input().split()))
s = [0] * (A + 2)
t = [0] * (B + 2)
X = [0] * Q
s[0] = -float("inf")
s[A + 1] = float("inf")
t[0] = -float("inf")
t[B + 1] = float("inf")
for i in range(1, A + 1):
s[i] = int(eval(input()))
for i in range(1, B + 1):
t[i] = int(eval(input()))
for i in range(Q):
X[i] = int(eval(input()))
import bisect
for x in X:
s_i = bisect.bisect_left(s, x)
t_i = bisect.bisect_left(t, x)
s_l = abs(s[s_i - 1] - x)
s_r = s[s_i] - x
t_l = abs(t[t_i - 1] - x)
t_r = t[t_i] - x
ans = min(
[
max(s_l, t_l),
s_l + t_r + min(s_l, t_r),
s_r + t_l + min(s_r, t_l),
max(s_r, t_r),
]
)
print(ans)
| ri = lambda: int(eval(input()))
rl = lambda: list(map(int, input().split()))
A, B, Q = rl()
s = [0] * (A + 2)
t = [0] * (B + 2)
X = [0] * Q
for i in range(1, A + 1):
s[i] = ri()
s[0], s[A + 1] = -float("inf"), float("inf")
s.sort()
for i in range(1, B + 1):
t[i] = ri()
t[0], t[B + 1] = -float("inf"), float("inf")
t.sort()
for i in range(Q):
X[i] = ri()
import bisect
for x in X:
s_i = bisect.bisect_left(s, x)
t_i = bisect.bisect_left(t, x)
s_l = x - s[s_i - 1]
s_r = s[s_i] - x
t_l = x - t[t_i - 1]
t_r = t[t_i] - x
ans = min(
[
max(s_l, t_l),
s_l + t_r + min(s_l, t_r),
s_r + t_l + min(s_r, t_l),
max(s_r, t_r),
]
)
print(ans)
| false | 3.333333 | [
"-A, B, Q = list(map(int, input().split()))",
"+ri = lambda: int(eval(input()))",
"+rl = lambda: list(map(int, input().split()))",
"+A, B, Q = rl()",
"-s[0] = -float(\"inf\")",
"-s[A + 1] = float(\"inf\")",
"-t[0] = -float(\"inf\")",
"-t[B + 1] = float(\"inf\")",
"- s[i] = int(eval(input()))",
"+ s[i] = ri()",
"+s[0], s[A + 1] = -float(\"inf\"), float(\"inf\")",
"+s.sort()",
"- t[i] = int(eval(input()))",
"+ t[i] = ri()",
"+t[0], t[B + 1] = -float(\"inf\"), float(\"inf\")",
"+t.sort()",
"- X[i] = int(eval(input()))",
"+ X[i] = ri()",
"- s_l = abs(s[s_i - 1] - x)",
"+ s_l = x - s[s_i - 1]",
"- t_l = abs(t[t_i - 1] - x)",
"+ t_l = x - t[t_i - 1]"
] | false | 0.035351 | 0.035728 | 0.989452 | [
"s696873180",
"s275639128"
] |
u498487134 | p02839 | python | s073388376 | s098314781 | 260 | 133 | 58,076 | 89,864 | Accepted | Accepted | 48.85 | import sys
input = sys.stdin.readline
H,W = list(map(int,input().split()))
#差分だけで良い，これを*1 or -1していく
diff = [list(map(int, input().split())) for _ in range(H)]
for i in range(H):
B = list(map(int,input().split()))
for j in range(W):
diff[i][j] = abs(diff[i][j] - B[j])
# i,jマスにおいて，偏りがkになれるかどうかでDP
#dp[i][j]にはkという数字にたどり着けるかどうかを示す2進数を入れる
dp = [[False]*W for _ in range(H)]
ofs = 80*(H+W)
dp[0][0]=(1<<(ofs+diff[0][0]) | 1>>(ofs-diff[0][0]))
for i in range(H):
for j in range(W):
if i>0:
dp[i][j]|=(dp[i-1][j]<<diff[i][j] | dp[i-1][j]>>diff[i][j])
if j>0:
dp[i][j]|=(dp[i][j-1]<<diff[i][j] | dp[i][j-1]>>diff[i][j])
#0のところから見て，最初に1が出てきたところが答え
for k in range(ofs):
if (dp[-1][-1]>>(k+ofs)&1):
print(k)
break | import sys
input = sys.stdin.readline
def I(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
"""
面倒なので差分を考えておく，
この差分を+ or - のどちらで使うかの2択，
合計値を0に近づけたい，
各マスごとに取れる範囲をsetで持ちながら，とやりたいが取れる範囲が多そうな気もする．
絶対値が6400を超える分は持つ必要ないな，ギリ行けるかも?
やっぱり遅いか.
dpだと遷移が遅そうだからsetにしようとしたけど，これも遅い．
dpで取れる値をいっぺんにシフトできれば高速化可能，めっちゃでかい二進数を用意する？
"""
def main():
mod=10**9+7
H,W=MI()
A=[]
B=[]
for i in range(H):
a=LI()
A.append(a)
for i in range(H):
b=LI()
B.append(b)
AB=[[0]*(W+1) for _ in range(H+1)]
for i in range(H):
for j in range(W):
ab=abs(A[i][j] - B[i][j])
AB[i][j]=ab
offset = 80*(H+W) #負数があるのでbitをずらす
dp=[[0]*(W+1) for _ in range(H+1)]
def calc(a,d):
# aをdだけ前後にずらす
return (a<<d) | (a>>d)
dp[0][0]=1<<(offset+AB[0][0]) | 1<<(offset-AB[0][0])
for i in range(H):
for j in range(W):
dp[i][j+1] = dp[i][j+1] | calc(dp[i][j],AB[i][j+1])
dp[i+1][j] = dp[i+1][j] | calc(dp[i][j],AB[i+1][j])
a=dp[-2][-2]
# 正負で対称なので片側だけで良い
a=a>>offset # ずらしたぶん戻す
for i in range(offset):
if a>>i & 1:
print(i)
break
# for i in range(H):
# for j in range(W):
# print(bin(dp[i][j]>>offset))
# # print(bin(dp[i][j]))
# print()
main()
| 34 | 78 | 828 | 1,621 | import sys
input = sys.stdin.readline
H, W = list(map(int, input().split()))
# 差分だけで良い，これを*1 or -1していく
diff = [list(map(int, input().split())) for _ in range(H)]
for i in range(H):
B = list(map(int, input().split()))
for j in range(W):
diff[i][j] = abs(diff[i][j] - B[j])
# i,jマスにおいて，偏りがkになれるかどうかでDP
# dp[i][j]にはkという数字にたどり着けるかどうかを示す2進数を入れる
dp = [[False] * W for _ in range(H)]
ofs = 80 * (H + W)
dp[0][0] = 1 << (ofs + diff[0][0]) | 1 >> (ofs - diff[0][0])
for i in range(H):
for j in range(W):
if i > 0:
dp[i][j] |= dp[i - 1][j] << diff[i][j] | dp[i - 1][j] >> diff[i][j]
if j > 0:
dp[i][j] |= dp[i][j - 1] << diff[i][j] | dp[i][j - 1] >> diff[i][j]
# 0のところから見て，最初に1が出てきたところが答え
for k in range(ofs):
if dp[-1][-1] >> (k + ofs) & 1:
print(k)
break
| import sys
input = sys.stdin.readline
def I():
return int(eval(input()))
def MI():
return list(map(int, input().split()))
def LI():
return list(map(int, input().split()))
"""
面倒なので差分を考えておく，
この差分を+ or - のどちらで使うかの2択，
合計値を0に近づけたい，
各マスごとに取れる範囲をsetで持ちながら，とやりたいが取れる範囲が多そうな気もする．
絶対値が6400を超える分は持つ必要ないな，ギリ行けるかも?
やっぱり遅いか.
dpだと遷移が遅そうだからsetにしようとしたけど，これも遅い．
dpで取れる値をいっぺんにシフトできれば高速化可能，めっちゃでかい二進数を用意する？
"""
def main():
mod = 10**9 + 7
H, W = MI()
A = []
B = []
for i in range(H):
a = LI()
A.append(a)
for i in range(H):
b = LI()
B.append(b)
AB = [[0] * (W + 1) for _ in range(H + 1)]
for i in range(H):
for j in range(W):
ab = abs(A[i][j] - B[i][j])
AB[i][j] = ab
offset = 80 * (H + W) # 負数があるのでbitをずらす
dp = [[0] * (W + 1) for _ in range(H + 1)]
def calc(a, d):
# aをdだけ前後にずらす
return (a << d) | (a >> d)
dp[0][0] = 1 << (offset + AB[0][0]) | 1 << (offset - AB[0][0])
for i in range(H):
for j in range(W):
dp[i][j + 1] = dp[i][j + 1] | calc(dp[i][j], AB[i][j + 1])
dp[i + 1][j] = dp[i + 1][j] | calc(dp[i][j], AB[i + 1][j])
a = dp[-2][-2]
# 正負で対称なので片側だけで良い
a = a >> offset # ずらしたぶん戻す
for i in range(offset):
if a >> i & 1:
print(i)
break
# for i in range(H):
# for j in range(W):
# print(bin(dp[i][j]>>offset))
# # print(bin(dp[i][j]))
# print()
main()
| false | 56.410256 | [
"-H, W = list(map(int, input().split()))",
"-# 差分だけで良い，これを*1 or -1していく",
"-diff = [list(map(int, input().split())) for _ in range(H)]",
"-for i in range(H):",
"- B = list(map(int, input().split()))",
"- for j in range(W):",
"- diff[i][j] = abs(diff[i][j] - B[j])",
"-# i,jマスにおいて，偏りがkになれるかどうかでDP",
"-# dp[i][j]にはkという数字にたどり着けるかどうかを示す2進数を入れる",
"-dp = [[False] * W for _ in range(H)]",
"-ofs = 80 * (H + W)",
"-dp[0][0] = 1 << (ofs + diff[0][0]) | 1 >> (ofs - diff[0][0])",
"-for i in range(H):",
"- for j in range(W):",
"- if i > 0:",
"- dp[i][j] |= dp[i - 1][j] << diff[i][j] | dp[i - 1][j] >> diff[i][j]",
"- if j > 0:",
"- dp[i][j] |= dp[i][j - 1] << diff[i][j] | dp[i][j - 1] >> diff[i][j]",
"-# 0のところから見て，最初に1が出てきたところが答え",
"-for k in range(ofs):",
"- if dp[-1][-1] >> (k + ofs) & 1:",
"- print(k)",
"- break",
"+",
"+",
"+def I():",
"+ return int(eval(input()))",
"+",
"+",
"+def MI():",
"+ return list(map(int, input().split()))",
"+",
"+",
"+def LI():",
"+ return list(map(int, input().split()))",
"+",
"+",
"+\"\"\"",
"+面倒なので差分を考えておく，",
"+この差分を+ or - のどちらで使うかの2択，",
"+合計値を0に近づけたい，",
"+各マスごとに取れる範囲をsetで持ちながら，とやりたいが取れる範囲が多そうな気もする．",
"+絶対値が6400を超える分は持つ必要ないな，ギリ行けるかも?",
"+やっぱり遅いか.",
"+dpだと遷移が遅そうだからsetにしようとしたけど，これも遅い．",
"+dpで取れる値をいっぺんにシフトできれば高速化可能，めっちゃでかい二進数を用意する？",
"+\"\"\"",
"+",
"+",
"+def main():",
"+ mod = 10**9 + 7",
"+ H, W = MI()",
"+ A = []",
"+ B = []",
"+ for i in range(H):",
"+ a = LI()",
"+ A.append(a)",
"+ for i in range(H):",
"+ b = LI()",
"+ B.append(b)",
"+ AB = [[0] * (W + 1) for _ in range(H + 1)]",
"+ for i in range(H):",
"+ for j in range(W):",
"+ ab = abs(A[i][j] - B[i][j])",
"+ AB[i][j] = ab",
"+ offset = 80 * (H + W) # 負数があるのでbitをずらす",
"+ dp = [[0] * (W + 1) for _ in range(H + 1)]",
"+",
"+ def calc(a, d):",
"+ # aをdだけ前後にずらす",
"+ return (a << d) | (a >> d)",
"+",
"+ dp[0][0] = 1 << (offset + AB[0][0]) | 1 << (offset - AB[0][0])",
"+ for i in range(H):",
"+ for j in range(W):",
"+ dp[i][j + 1] = dp[i][j + 1] | calc(dp[i][j], AB[i][j + 1])",
"+ dp[i + 1][j] = dp[i + 1][j] | calc(dp[i][j], AB[i + 1][j])",
"+ a = dp[-2][-2]",
"+ # 正負で対称なので片側だけで良い",
"+ a = a >> offset # ずらしたぶん戻す",
"+ for i in range(offset):",
"+ if a >> i & 1:",
"+ print(i)",
"+ break",
"+ # for i in range(H):",
"+ # for j in range(W):",
"+ # print(bin(dp[i][j]>>offset))",
"+ # # print(bin(dp[i][j]))",
"+ # print()",
"+",
"+",
"+main()"
] | false | 0.040724 | 0.034691 | 1.173905 | [
"s073388376",
"s098314781"
] |
u444069166 | p02912 | python | s462114288 | s576185667 | 1,483 | 392 | 128,984 | 78,316 | Accepted | Accepted | 73.57 | #!/usr/bin/python3
from fractions import Fraction
import heapq
import math
import sys
DEBUG = False
def inp():
return sys.stdin.readline().rstrip()
def dprint(*value, sep=' ', end='\n'):
if DEBUG:
print(*value, sep=sep, end=end)
def solve(N, M, A):
hq = [-a for a in A]
heapq.heapify(hq)
for _ in range(M):
v = -hq[0]
if v < 1:
break
v = Fraction(v, 2)
heapq.heapreplace(hq, -v)
return sum([math.floor(-v) for v in hq])
def main():
N, M = [int(e) for e in input().split()]
A = [int(e) for e in input().split()]
print(solve(N, M, A))
if __name__ == '__main__':
main()
| #!/usr/bin/python3
import heapq
import math
import sys
DEBUG = False
def inp():
return sys.stdin.readline().rstrip()
def dprint(*value, sep=' ', end='\n'):
if DEBUG:
print(*value, sep=sep, end=end)
def solve(N, M, A):
hq = [-a for a in A]
heapq.heapify(hq)
for _ in range(M):
v = -hq[0]
if v < 1:
break
v //= 2
heapq.heapreplace(hq, -v)
return sum([math.floor(-v) for v in hq])
def main():
N, M = [int(e) for e in input().split()]
A = [int(e) for e in input().split()]
print(solve(N, M, A))
if __name__ == '__main__':
main()
| 41 | 40 | 713 | 670 | #!/usr/bin/python3
from fractions import Fraction
import heapq
import math
import sys
DEBUG = False
def inp():
return sys.stdin.readline().rstrip()
def dprint(*value, sep=" ", end="\n"):
if DEBUG:
print(*value, sep=sep, end=end)
def solve(N, M, A):
hq = [-a for a in A]
heapq.heapify(hq)
for _ in range(M):
v = -hq[0]
if v < 1:
break
v = Fraction(v, 2)
heapq.heapreplace(hq, -v)
return sum([math.floor(-v) for v in hq])
def main():
N, M = [int(e) for e in input().split()]
A = [int(e) for e in input().split()]
print(solve(N, M, A))
if __name__ == "__main__":
main()
| #!/usr/bin/python3
import heapq
import math
import sys
DEBUG = False
def inp():
return sys.stdin.readline().rstrip()
def dprint(*value, sep=" ", end="\n"):
if DEBUG:
print(*value, sep=sep, end=end)
def solve(N, M, A):
hq = [-a for a in A]
heapq.heapify(hq)
for _ in range(M):
v = -hq[0]
if v < 1:
break
v //= 2
heapq.heapreplace(hq, -v)
return sum([math.floor(-v) for v in hq])
def main():
N, M = [int(e) for e in input().split()]
A = [int(e) for e in input().split()]
print(solve(N, M, A))
if __name__ == "__main__":
main()
| false | 2.439024 | [
"-from fractions import Fraction",
"- v = Fraction(v, 2)",
"+ v //= 2"
] | false | 0.044601 | 0.206198 | 0.216302 | [
"s462114288",
"s576185667"
] |
u216392490 | p02554 | python | s431860040 | s327625343 | 380 | 59 | 86,360 | 61,704 | Accepted | Accepted | 84.47 | n = int(eval(input()))
mod = 10**9 + 7
ans = (10**n - 9**n - 9**n + 8**n) % mod
print(ans)
| n = int(eval(input()))
mod = 10**9 + 7
ans = pow(10, n, mod)
ans += -2 * pow(9, n, mod)
ans += pow(8, n, mod)
print((ans%mod))
| 5 | 7 | 90 | 126 | n = int(eval(input()))
mod = 10**9 + 7
ans = (10**n - 9**n - 9**n + 8**n) % mod
print(ans)
| n = int(eval(input()))
mod = 10**9 + 7
ans = pow(10, n, mod)
ans += -2 * pow(9, n, mod)
ans += pow(8, n, mod)
print((ans % mod))
| false | 28.571429 | [
"-ans = (10**n - 9**n - 9**n + 8**n) % mod",
"-print(ans)",
"+ans = pow(10, n, mod)",
"+ans += -2 * pow(9, n, mod)",
"+ans += pow(8, n, mod)",
"+print((ans % mod))"
] | false | 0.116707 | 0.044945 | 2.59665 | [
"s431860040",
"s327625343"
] |
u864197622 | p03776 | python | s511051438 | s144515318 | 19 | 17 | 3,064 | 3,064 | Accepted | Accepted | 10.53 | from itertools import accumulate as ac
t = 3099044504245996706400 # LCM(1..50)
N, A, B = list(map(int, input().split()))
V = sorted([int(a) * t for a in input().split()])[::-1]
l, r = 0, 1<<200
while r - l > 1:
m = (l+r) // 2
if list(ac([v-m for v in V]))[A-1] >= 0:
l = m
else:
r = m
fa = [1]
for i in range(1, 60):
fa.append(fa[-1] * i)
C = lambda a, b: fa[a] // (fa[a-b] * fa[b])
print((l/t))
print((sum([C(V.count(V[i-1]), V[:i].count(V[i-1])) for i in range(A, B+1) if sum(V[:i]) == l * i]))) | N, A, B = list(map(int, input().split()))
V = sorted([int(a) for a in input().split()])[::-1]
fa = [1]
for i in range(1, 60): fa.append(fa[-1] * i)
C = lambda a, b: fa[a] // (fa[a-b] * fa[b])
print((sum(V[:A])/A))
print((sum([C(V.count(V[i-1]), V[:i].count(V[i-1])) for i in range(A, B+1) if sum(V[:i])*A == sum(V[:A])*i]))) | 19 | 9 | 539 | 324 | from itertools import accumulate as ac
t = 3099044504245996706400 # LCM(1..50)
N, A, B = list(map(int, input().split()))
V = sorted([int(a) * t for a in input().split()])[::-1]
l, r = 0, 1 << 200
while r - l > 1:
m = (l + r) // 2
if list(ac([v - m for v in V]))[A - 1] >= 0:
l = m
else:
r = m
fa = [1]
for i in range(1, 60):
fa.append(fa[-1] * i)
C = lambda a, b: fa[a] // (fa[a - b] * fa[b])
print((l / t))
print(
(
sum(
[
C(V.count(V[i - 1]), V[:i].count(V[i - 1]))
for i in range(A, B + 1)
if sum(V[:i]) == l * i
]
)
)
)
| N, A, B = list(map(int, input().split()))
V = sorted([int(a) for a in input().split()])[::-1]
fa = [1]
for i in range(1, 60):
fa.append(fa[-1] * i)
C = lambda a, b: fa[a] // (fa[a - b] * fa[b])
print((sum(V[:A]) / A))
print(
(
sum(
[
C(V.count(V[i - 1]), V[:i].count(V[i - 1]))
for i in range(A, B + 1)
if sum(V[:i]) * A == sum(V[:A]) * i
]
)
)
)
| false | 52.631579 | [
"-from itertools import accumulate as ac",
"-",
"-t = 3099044504245996706400 # LCM(1..50)",
"-V = sorted([int(a) * t for a in input().split()])[::-1]",
"-l, r = 0, 1 << 200",
"-while r - l > 1:",
"- m = (l + r) // 2",
"- if list(ac([v - m for v in V]))[A - 1] >= 0:",
"- l = m",
"- else:",
"- r = m",
"+V = sorted([int(a) for a in input().split()])[::-1]",
"-print((l / t))",
"+print((sum(V[:A]) / A))",
"- if sum(V[:i]) == l * i",
"+ if sum(V[:i]) * A == sum(V[:A]) * i"
] | false | 0.047332 | 0.047132 | 1.004224 | [
"s511051438",
"s144515318"
] |
u970197315 | p02691 | python | s990863443 | s533115331 | 279 | 192 | 63,196 | 50,256 | Accepted | Accepted | 31.18 | n=int(eval(input()))
a=list(map(int,input().split()))
from collections import Counter
ai,aj=[],[]
for i in range(n):
aj.append(i-a[i])
ai.append(i+a[i])
c1=Counter(ai)
c2=Counter(aj)
ans=0
for k in list(c1.keys()):
ans+=c1[k]*c2[k]
print(ans)
| n = int(eval(input()))
a = list(map(int,input().split()))
x = [ aa + i for i,aa in enumerate(a,start = 1)]
y = [ i - aa for i,aa in enumerate(a,start = 1)]
from collections import Counter
c = Counter(y)
ans = 0
for xx in x:
ans += c[xx]
print(ans)
| 15 | 15 | 253 | 267 | n = int(eval(input()))
a = list(map(int, input().split()))
from collections import Counter
ai, aj = [], []
for i in range(n):
aj.append(i - a[i])
ai.append(i + a[i])
c1 = Counter(ai)
c2 = Counter(aj)
ans = 0
for k in list(c1.keys()):
ans += c1[k] * c2[k]
print(ans)
| n = int(eval(input()))
a = list(map(int, input().split()))
x = [aa + i for i, aa in enumerate(a, start=1)]
y = [i - aa for i, aa in enumerate(a, start=1)]
from collections import Counter
c = Counter(y)
ans = 0
for xx in x:
ans += c[xx]
print(ans)
| false | 0 | [
"+x = [aa + i for i, aa in enumerate(a, start=1)]",
"+y = [i - aa for i, aa in enumerate(a, start=1)]",
"-ai, aj = [], []",
"-for i in range(n):",
"- aj.append(i - a[i])",
"- ai.append(i + a[i])",
"-c1 = Counter(ai)",
"-c2 = Counter(aj)",
"+c = Counter(y)",
"-for k in list(c1.keys()):",
"- ans += c1[k] * c2[k]",
"+for xx in x:",
"+ ans += c[xx]"
] | false | 0.046705 | 0.046449 | 1.005519 | [
"s990863443",
"s533115331"
] |
u562935282 | p03338 | python | s182952932 | s593784474 | 24 | 18 | 3,772 | 3,064 | Accepted | Accepted | 25 | from string import ascii_lowercase
n = int(eval(input()))
s = eval(input())
ans = -1
for mid in range(1, n):
# [0, mid), [mid, n)
left = set(s[:mid])
right = set(s[mid:])
cnt = 0
for c in ascii_lowercase:
if c in left and c in right:
cnt += 1
ans = max(ans, cnt)
print(ans)
| def main():
N = int(eval(input()))
s = eval(input())
acc = []
t = [0] * 26
for c in s:
i = ord(c) - ord('a')
t[i] += 1
acc.append(t.copy())
ans = 0
for i in range(N - 1):
left = acc[i]
right = [cn - ci for ci, cn in zip(acc[i], acc[N - 1])]
cnt = 0
for ci in range(26):
if left[ci] and right[ci]:
cnt += 1
ans = max(ans, cnt)
print(ans)
if __name__ == '__main__':
main()
| 17 | 25 | 325 | 519 | from string import ascii_lowercase
n = int(eval(input()))
s = eval(input())
ans = -1
for mid in range(1, n):
# [0, mid), [mid, n)
left = set(s[:mid])
right = set(s[mid:])
cnt = 0
for c in ascii_lowercase:
if c in left and c in right:
cnt += 1
ans = max(ans, cnt)
print(ans)
| def main():
N = int(eval(input()))
s = eval(input())
acc = []
t = [0] * 26
for c in s:
i = ord(c) - ord("a")
t[i] += 1
acc.append(t.copy())
ans = 0
for i in range(N - 1):
left = acc[i]
right = [cn - ci for ci, cn in zip(acc[i], acc[N - 1])]
cnt = 0
for ci in range(26):
if left[ci] and right[ci]:
cnt += 1
ans = max(ans, cnt)
print(ans)
if __name__ == "__main__":
main()
| false | 32 | [
"-from string import ascii_lowercase",
"+def main():",
"+ N = int(eval(input()))",
"+ s = eval(input())",
"+ acc = []",
"+ t = [0] * 26",
"+ for c in s:",
"+ i = ord(c) - ord(\"a\")",
"+ t[i] += 1",
"+ acc.append(t.copy())",
"+ ans = 0",
"+ for i in range(N - 1):",
"+ left = acc[i]",
"+ right = [cn - ci for ci, cn in zip(acc[i], acc[N - 1])]",
"+ cnt = 0",
"+ for ci in range(26):",
"+ if left[ci] and right[ci]:",
"+ cnt += 1",
"+ ans = max(ans, cnt)",
"+ print(ans)",
"-n = int(eval(input()))",
"-s = eval(input())",
"-ans = -1",
"-for mid in range(1, n):",
"- # [0, mid), [mid, n)",
"- left = set(s[:mid])",
"- right = set(s[mid:])",
"- cnt = 0",
"- for c in ascii_lowercase:",
"- if c in left and c in right:",
"- cnt += 1",
"- ans = max(ans, cnt)",
"-print(ans)",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false | 0.125416 | 0.045464 | 2.758584 | [
"s182952932",
"s593784474"
] |
u206133536 | p02657 | python | s951435373 | s806519242 | 105 | 68 | 60,848 | 61,856 | Accepted | Accepted | 35.24 | print((eval(input().replace(' ','*')))) | st = input().strip().split()
a = int(st[0])
b = int(float(st[1])*1000)
print((a*b//1000)) | 1 | 4 | 37 | 90 | print((eval(input().replace(" ", "*"))))
| st = input().strip().split()
a = int(st[0])
b = int(float(st[1]) * 1000)
print((a * b // 1000))
| false | 75 | [
"-print((eval(input().replace(\" \", \"*\"))))",
"+st = input().strip().split()",
"+a = int(st[0])",
"+b = int(float(st[1]) * 1000)",
"+print((a * b // 1000))"
] | false | 0.044429 | 0.083292 | 0.533409 | [
"s951435373",
"s806519242"
] |
u726615467 | p03013 | python | s890517183 | s689739513 | 244 | 176 | 7,848 | 7,848 | Accepted | Accepted | 27.87 | N, M = list(map(int, input().split()))
a = [int(eval(input())) for _ in range(M)]
a.sort()
a.append(10 ** 9 + 7)
a.append(10 ** 9 + 7)
memo = [0] * (N + 1)
memo[0] = 1
idx = 0
for pos in range(1, N + 1):
if a[idx] == pos:
memo[pos] = 0
for i in range(idx, N):
if a[i] > pos: break
idx = i
continue
else:
if pos > a[idx]:
for i in range(idx, N):
if a[i] > pos: break
idx = i
#
if pos == 1:
memo[1] = (memo[0]) % (10 ** 9 + 7)
else:
memo[pos] = (memo[pos - 2] + memo[pos - 1]) % (10 ** 9 + 7)
# print("#", memo)
print((memo[-1])) | # -*- coding: utf-8 -*-
MOD = 1000000007
N, M = list(map(int, input().split()))
a = []
for _ in range(M):
a.append(int(eval(input())))
def getPatternNum(num):
pattern = [0] * (num + 2)
pattern[0] = 0
for i in range(1, num + 2):
if i == 0 or i == 1:
pattern[i] = 1
continue
pattern[i] = (pattern[i - 2] + pattern[i - 1]) % MOD
return pattern
def solve():
# 階段の連続してる数のリスト
stepsList = [0] * (M + 1)
maxSteps = 0
if M > 0:
stepsList[0] = a[0]
for j in range(1, M):
stepsList[j] = a[j] - a[j - 1] - 1
if stepsList[j] == 0:
return 0
stepsList[M] = N - a[M - 1]
else:
stepsList = [N + 1]
pattern = getPatternNum(max(stepsList) + 1)
# こわれてるところ以外のパターンを掛ける
# print("#", pattern)
for k in range(len(stepsList)):
if k == 0:
total = pattern[stepsList[k]]
else:
total = (total * pattern[stepsList[k]]) % MOD
# print("##", k, stepsList[k], pattern[stepsList[k]], total)
return total
ans = solve()
print(ans) | 30 | 46 | 693 | 1,151 | N, M = list(map(int, input().split()))
a = [int(eval(input())) for _ in range(M)]
a.sort()
a.append(10**9 + 7)
a.append(10**9 + 7)
memo = [0] * (N + 1)
memo[0] = 1
idx = 0
for pos in range(1, N + 1):
if a[idx] == pos:
memo[pos] = 0
for i in range(idx, N):
if a[i] > pos:
break
idx = i
continue
else:
if pos > a[idx]:
for i in range(idx, N):
if a[i] > pos:
break
idx = i
#
if pos == 1:
memo[1] = (memo[0]) % (10**9 + 7)
else:
memo[pos] = (memo[pos - 2] + memo[pos - 1]) % (10**9 + 7)
# print("#", memo)
print((memo[-1]))
| # -*- coding: utf-8 -*-
MOD = 1000000007
N, M = list(map(int, input().split()))
a = []
for _ in range(M):
a.append(int(eval(input())))
def getPatternNum(num):
pattern = [0] * (num + 2)
pattern[0] = 0
for i in range(1, num + 2):
if i == 0 or i == 1:
pattern[i] = 1
continue
pattern[i] = (pattern[i - 2] + pattern[i - 1]) % MOD
return pattern
def solve():
# 階段の連続してる数のリスト
stepsList = [0] * (M + 1)
maxSteps = 0
if M > 0:
stepsList[0] = a[0]
for j in range(1, M):
stepsList[j] = a[j] - a[j - 1] - 1
if stepsList[j] == 0:
return 0
stepsList[M] = N - a[M - 1]
else:
stepsList = [N + 1]
pattern = getPatternNum(max(stepsList) + 1)
# こわれてるところ以外のパターンを掛ける
# print("#", pattern)
for k in range(len(stepsList)):
if k == 0:
total = pattern[stepsList[k]]
else:
total = (total * pattern[stepsList[k]]) % MOD
# print("##", k, stepsList[k], pattern[stepsList[k]], total)
return total
ans = solve()
print(ans)
| false | 34.782609 | [
"+# -*- coding: utf-8 -*-",
"+MOD = 1000000007",
"-a = [int(eval(input())) for _ in range(M)]",
"-a.sort()",
"-a.append(10**9 + 7)",
"-a.append(10**9 + 7)",
"-memo = [0] * (N + 1)",
"-memo[0] = 1",
"-idx = 0",
"-for pos in range(1, N + 1):",
"- if a[idx] == pos:",
"- memo[pos] = 0",
"- for i in range(idx, N):",
"- if a[i] > pos:",
"- break",
"- idx = i",
"- continue",
"+a = []",
"+for _ in range(M):",
"+ a.append(int(eval(input())))",
"+",
"+",
"+def getPatternNum(num):",
"+ pattern = [0] * (num + 2)",
"+ pattern[0] = 0",
"+ for i in range(1, num + 2):",
"+ if i == 0 or i == 1:",
"+ pattern[i] = 1",
"+ continue",
"+ pattern[i] = (pattern[i - 2] + pattern[i - 1]) % MOD",
"+ return pattern",
"+",
"+",
"+def solve():",
"+ # 階段の連続してる数のリスト",
"+ stepsList = [0] * (M + 1)",
"+ maxSteps = 0",
"+ if M > 0:",
"+ stepsList[0] = a[0]",
"+ for j in range(1, M):",
"+ stepsList[j] = a[j] - a[j - 1] - 1",
"+ if stepsList[j] == 0:",
"+ return 0",
"+ stepsList[M] = N - a[M - 1]",
"- if pos > a[idx]:",
"- for i in range(idx, N):",
"- if a[i] > pos:",
"- break",
"- idx = i",
"- #",
"- if pos == 1:",
"- memo[1] = (memo[0]) % (10**9 + 7)",
"+ stepsList = [N + 1]",
"+ pattern = getPatternNum(max(stepsList) + 1)",
"+ # こわれてるところ以外のパターンを掛ける",
"+ # print(\"#\", pattern)",
"+ for k in range(len(stepsList)):",
"+ if k == 0:",
"+ total = pattern[stepsList[k]]",
"- memo[pos] = (memo[pos - 2] + memo[pos - 1]) % (10**9 + 7)",
"-# print(\"#\", memo)",
"-print((memo[-1]))",
"+ total = (total * pattern[stepsList[k]]) % MOD",
"+ # print(\"##\", k, stepsList[k], pattern[stepsList[k]], total)",
"+ return total",
"+",
"+",
"+ans = solve()",
"+print(ans)"
] | false | 0.091077 | 0.036539 | 2.492577 | [
"s890517183",
"s689739513"
] |
u901582103 | p03086 | python | s017169606 | s811245672 | 19 | 17 | 2,940 | 2,940 | Accepted | Accepted | 10.53 | S=eval(input())
r=0
c=0
for s in S:
if s=='A'or s=='T'or s=='C'or s=='G':
c+=1
r=max(r,c)
else:
c=0
print(r) | S=eval(input())
c=0
r=0
for s in S:
if s in 'ATCG':
c+=1
r=max(r,c)
else:
c=0
print(r) | 10 | 10 | 143 | 121 | S = eval(input())
r = 0
c = 0
for s in S:
if s == "A" or s == "T" or s == "C" or s == "G":
c += 1
r = max(r, c)
else:
c = 0
print(r)
| S = eval(input())
c = 0
r = 0
for s in S:
if s in "ATCG":
c += 1
r = max(r, c)
else:
c = 0
print(r)
| false | 0 | [
"+c = 0",
"-c = 0",
"- if s == \"A\" or s == \"T\" or s == \"C\" or s == \"G\":",
"+ if s in \"ATCG\":"
] | false | 0.048077 | 0.047428 | 1.013666 | [
"s017169606",
"s811245672"
] |
u816631826 | p03836 | python | s846206747 | s341327579 | 38 | 17 | 4,596 | 3,064 | Accepted | Accepted | 55.26 | sx, sy, tx, ty = map(int, input().split(" "))
tx -= sx
ty -= sy
sx = 0
sy = 0
line = []
for i in range(tx):
line.append("R")
for i in range(ty):
line.append("U")
for i in range(tx):
line.append("L")
for i in range(ty):
line.append("D")
line.append("D")
for i in range(tx+1):
line.append("R")
for i in range(ty+1):
line.append("U")
line.append("L")
line.append("U")
for i in range(tx+1):
line.append("L")
for i in range(ty+1):
line.append("D")
line.append("R")
for i in range(len(line)):
if i<len(line):
print(line[i], end = "")
else:
print(line[i])
| sx,sy,tx,ty = list([int(x) for x in input().split(" ")])
route = ""
route += "U" * (ty-sy)
route += "R" * (tx-sx)
route += "D" * (ty-sy)
route += "L" * (tx-sx)
route += "L"
route += "U" * (ty-sy+1)
route += "R" * (tx-sx+1)
route += "D"
route += "R"
route += "D" * (ty-sy+1)
route += "L" * (tx-sx+1)
route += "U"
print(route) | 31 | 17 | 634 | 347 | sx, sy, tx, ty = map(int, input().split(" "))
tx -= sx
ty -= sy
sx = 0
sy = 0
line = []
for i in range(tx):
line.append("R")
for i in range(ty):
line.append("U")
for i in range(tx):
line.append("L")
for i in range(ty):
line.append("D")
line.append("D")
for i in range(tx + 1):
line.append("R")
for i in range(ty + 1):
line.append("U")
line.append("L")
line.append("U")
for i in range(tx + 1):
line.append("L")
for i in range(ty + 1):
line.append("D")
line.append("R")
for i in range(len(line)):
if i < len(line):
print(line[i], end="")
else:
print(line[i])
| sx, sy, tx, ty = list([int(x) for x in input().split(" ")])
route = ""
route += "U" * (ty - sy)
route += "R" * (tx - sx)
route += "D" * (ty - sy)
route += "L" * (tx - sx)
route += "L"
route += "U" * (ty - sy + 1)
route += "R" * (tx - sx + 1)
route += "D"
route += "R"
route += "D" * (ty - sy + 1)
route += "L" * (tx - sx + 1)
route += "U"
print(route)
| false | 45.16129 | [
"-sx, sy, tx, ty = map(int, input().split(\" \"))",
"-tx -= sx",
"-ty -= sy",
"-sx = 0",
"-sy = 0",
"-line = []",
"-for i in range(tx):",
"- line.append(\"R\")",
"-for i in range(ty):",
"- line.append(\"U\")",
"-for i in range(tx):",
"- line.append(\"L\")",
"-for i in range(ty):",
"- line.append(\"D\")",
"-line.append(\"D\")",
"-for i in range(tx + 1):",
"- line.append(\"R\")",
"-for i in range(ty + 1):",
"- line.append(\"U\")",
"-line.append(\"L\")",
"-line.append(\"U\")",
"-for i in range(tx + 1):",
"- line.append(\"L\")",
"-for i in range(ty + 1):",
"- line.append(\"D\")",
"-line.append(\"R\")",
"-for i in range(len(line)):",
"- if i < len(line):",
"- print(line[i], end=\"\")",
"- else:",
"- print(line[i])",
"+sx, sy, tx, ty = list([int(x) for x in input().split(\" \")])",
"+route = \"\"",
"+route += \"U\" * (ty - sy)",
"+route += \"R\" * (tx - sx)",
"+route += \"D\" * (ty - sy)",
"+route += \"L\" * (tx - sx)",
"+route += \"L\"",
"+route += \"U\" * (ty - sy + 1)",
"+route += \"R\" * (tx - sx + 1)",
"+route += \"D\"",
"+route += \"R\"",
"+route += \"D\" * (ty - sy + 1)",
"+route += \"L\" * (tx - sx + 1)",
"+route += \"U\"",
"+print(route)"
] | false | 0.038878 | 0.036858 | 1.054803 | [
"s846206747",
"s341327579"
] |
u588341295 | p03436 | python | s574761333 | s284426781 | 37 | 30 | 3,692 | 3,444 | Accepted | Accepted | 18.92 | # -*- coding: utf-8 -*-
import sys
input = sys.stdin.readline
from collections import deque
H, W = list(map(int, input().split()))
start, goal = (1, 1), (H, W)
# 左右上下
directions = [[0,-1],[0,1],[-1,0],[1,0]]
# 四方に一回り大きいフィールドを作る
field = [['*'] * (W+2) for i in range(H+2)]
for i in range(1,H+1):
row = list(eval(input()))[:-1]
for j in range(1, W+1):
field[i][j] = row[j-1]
# 移動距離メモ
memo = [[float('inf')] * (W+2) for i in range(H+2)]
memo[start[0]][start[1]] = 0
# 訪問済メモ
visited = [[0] * (W+2) for i in range(H+2)]
# 移動元メモ
prevs = [[None] * (W+2) for i in range(H+2)]
def bfs():
que = deque()
# スタート位置
que.append(start)
while len(que) != 0:
cur = que.popleft()
# 見終わった場所はもうやらない
if visited[cur[0]][cur[1]] == 1:
continue
# 訪問済にする
visited[cur[0]][cur[1]] = 1
# 4方向見る
for direction in directions:
# 上下左右に1つずつ動かした座標
nxt = list(map(lambda x,y: x+y, cur, direction))
# 壁か黒マスはスキップ
if field[nxt[0]][nxt[1]] == '*' or field[nxt[0]][nxt[1]] == '#':
continue
# 現在位置+1の距離を移動先に記録
if field[nxt[0]][nxt[1]] == '.' and memo[nxt[0]][nxt[1]] > memo[cur[0]][cur[1]] + 1:
memo[nxt[0]][nxt[1]] = memo[cur[0]][cur[1]] + 1
# ここで移動元のマスを記録
prevs[nxt[0]][nxt[1]] = (cur[0], cur[1])
# キューに次のマスを足す
que.append(nxt)
# 最短経路を出す
bfs()
# ゴールに辿り着けない場合
if memo[goal[0]][goal[1]] == float('inf'):
print((-1))
exit()
# 最短経路で使うマスに目印をつける
field[goal[0]][goal[1]] = '@'
nxt = prevs[goal[0]][goal[1]]
for _ in range(memo[goal[0]][goal[1]]):
field[nxt[0]][nxt[1]] = '@'
nxt = prevs[nxt[0]][nxt[1]]
# 残っている白マスが塗り替えられる場所
ans = 0
for i in range(1,H+1):
for j in range(1, W+1):
if field[i][j] == '.':
ans += 1
print(ans)
| # -*- coding: utf-8 -*-
import sys
from collections import deque
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def build_grid(H, W, intv, _type, space=True, padding=False):
# 入力がスペース区切りかどうか
if space:
_input = lambda: input().split()
else:
_input = lambda: eval(input())
_list = lambda: list(map(_type, _input()))
# 余白の有無
if padding:
offset = 1
else:
offset = 0
grid = list2d(H+offset*2, W+offset*2, intv)
for i in range(offset, H+offset):
row = _list()
for j in range(offset, W+offset):
grid[i][j] = row[j-offset]
return grid
H, W = MAP()
grid = build_grid(H, W, '#', str, space=False, padding=True)
# グリッドBFS
directions = ((1,0),(-1,0),(0,1),(0,-1))
que = deque([(1, 1, 0)])
dist = list2d(H+2, W+2, INF)
while que:
h, w, c = que.popleft()
if dist[h][w] != INF:
continue
dist[h][w] = c
for dh, dw in directions:
h2 = h + dh
w2 = w + dw
if grid[h2][w2] == '#':
continue
que.append((h2, w2, c+1))
# ゴール到達不可
if dist[H][W] == INF:
print((-1))
exit()
# 経路復元
que = deque([(H, W)])
while que:
h, w = que.popleft()
grid[h][w] = '@'
for dh, dw in directions:
h2 = h + dh
w2 = w + dw
if dist[h2][w2] == dist[h][w] - 1:
que.append((h2, w2))
break
# 最短経路で通る場所以外をカウント
ans = 0
for i in range(1, H+1):
for j in range(1, W+1):
if grid[i][j] == '.':
ans += 1
print(ans)
| 72 | 83 | 1,945 | 2,188 | # -*- coding: utf-8 -*-
import sys
input = sys.stdin.readline
from collections import deque
H, W = list(map(int, input().split()))
start, goal = (1, 1), (H, W)
# 左右上下
directions = [[0, -1], [0, 1], [-1, 0], [1, 0]]
# 四方に一回り大きいフィールドを作る
field = [["*"] * (W + 2) for i in range(H + 2)]
for i in range(1, H + 1):
row = list(eval(input()))[:-1]
for j in range(1, W + 1):
field[i][j] = row[j - 1]
# 移動距離メモ
memo = [[float("inf")] * (W + 2) for i in range(H + 2)]
memo[start[0]][start[1]] = 0
# 訪問済メモ
visited = [[0] * (W + 2) for i in range(H + 2)]
# 移動元メモ
prevs = [[None] * (W + 2) for i in range(H + 2)]
def bfs():
que = deque()
# スタート位置
que.append(start)
while len(que) != 0:
cur = que.popleft()
# 見終わった場所はもうやらない
if visited[cur[0]][cur[1]] == 1:
continue
# 訪問済にする
visited[cur[0]][cur[1]] = 1
# 4方向見る
for direction in directions:
# 上下左右に1つずつ動かした座標
nxt = list(map(lambda x, y: x + y, cur, direction))
# 壁か黒マスはスキップ
if field[nxt[0]][nxt[1]] == "*" or field[nxt[0]][nxt[1]] == "#":
continue
# 現在位置+1の距離を移動先に記録
if (
field[nxt[0]][nxt[1]] == "."
and memo[nxt[0]][nxt[1]] > memo[cur[0]][cur[1]] + 1
):
memo[nxt[0]][nxt[1]] = memo[cur[0]][cur[1]] + 1
# ここで移動元のマスを記録
prevs[nxt[0]][nxt[1]] = (cur[0], cur[1])
# キューに次のマスを足す
que.append(nxt)
# 最短経路を出す
bfs()
# ゴールに辿り着けない場合
if memo[goal[0]][goal[1]] == float("inf"):
print((-1))
exit()
# 最短経路で使うマスに目印をつける
field[goal[0]][goal[1]] = "@"
nxt = prevs[goal[0]][goal[1]]
for _ in range(memo[goal[0]][goal[1]]):
field[nxt[0]][nxt[1]] = "@"
nxt = prevs[nxt[0]][nxt[1]]
# 残っている白マスが塗り替えられる場所
ans = 0
for i in range(1, H + 1):
for j in range(1, W + 1):
if field[i][j] == ".":
ans += 1
print(ans)
| # -*- coding: utf-8 -*-
import sys
from collections import deque
def input():
return sys.stdin.readline().strip()
def list2d(a, b, c):
return [[c] * b for i in range(a)]
def list3d(a, b, c, d):
return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e):
return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1):
return int(-(-x // y))
def INT():
return int(eval(input()))
def MAP():
return list(map(int, input().split()))
def LIST(N=None):
return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes():
print("Yes")
def No():
print("No")
def YES():
print("YES")
def NO():
print("NO")
sys.setrecursionlimit(10**9)
INF = 10**18
MOD = 10**9 + 7
def build_grid(H, W, intv, _type, space=True, padding=False):
# 入力がスペース区切りかどうか
if space:
_input = lambda: input().split()
else:
_input = lambda: eval(input())
_list = lambda: list(map(_type, _input()))
# 余白の有無
if padding:
offset = 1
else:
offset = 0
grid = list2d(H + offset * 2, W + offset * 2, intv)
for i in range(offset, H + offset):
row = _list()
for j in range(offset, W + offset):
grid[i][j] = row[j - offset]
return grid
H, W = MAP()
grid = build_grid(H, W, "#", str, space=False, padding=True)
# グリッドBFS
directions = ((1, 0), (-1, 0), (0, 1), (0, -1))
que = deque([(1, 1, 0)])
dist = list2d(H + 2, W + 2, INF)
while que:
h, w, c = que.popleft()
if dist[h][w] != INF:
continue
dist[h][w] = c
for dh, dw in directions:
h2 = h + dh
w2 = w + dw
if grid[h2][w2] == "#":
continue
que.append((h2, w2, c + 1))
# ゴール到達不可
if dist[H][W] == INF:
print((-1))
exit()
# 経路復元
que = deque([(H, W)])
while que:
h, w = que.popleft()
grid[h][w] = "@"
for dh, dw in directions:
h2 = h + dh
w2 = w + dw
if dist[h2][w2] == dist[h][w] - 1:
que.append((h2, w2))
break
# 最短経路で通る場所以外をカウント
ans = 0
for i in range(1, H + 1):
for j in range(1, W + 1):
if grid[i][j] == ".":
ans += 1
print(ans)
| false | 13.253012 | [
"-",
"-input = sys.stdin.readline",
"-H, W = list(map(int, input().split()))",
"-start, goal = (1, 1), (H, W)",
"-# 左右上下",
"-directions = [[0, -1], [0, 1], [-1, 0], [1, 0]]",
"-# 四方に一回り大きいフィールドを作る",
"-field = [[\"*\"] * (W + 2) for i in range(H + 2)]",
"-for i in range(1, H + 1):",
"- row = list(eval(input()))[:-1]",
"- for j in range(1, W + 1):",
"- field[i][j] = row[j - 1]",
"-# 移動距離メモ",
"-memo = [[float(\"inf\")] * (W + 2) for i in range(H + 2)]",
"-memo[start[0]][start[1]] = 0",
"-# 訪問済メモ",
"-visited = [[0] * (W + 2) for i in range(H + 2)]",
"-# 移動元メモ",
"-prevs = [[None] * (W + 2) for i in range(H + 2)]",
"+",
"+def input():",
"+ return sys.stdin.readline().strip()",
"-def bfs():",
"- que = deque()",
"- # スタート位置",
"- que.append(start)",
"- while len(que) != 0:",
"- cur = que.popleft()",
"- # 見終わった場所はもうやらない",
"- if visited[cur[0]][cur[1]] == 1:",
"- continue",
"- # 訪問済にする",
"- visited[cur[0]][cur[1]] = 1",
"- # 4方向見る",
"- for direction in directions:",
"- # 上下左右に1つずつ動かした座標",
"- nxt = list(map(lambda x, y: x + y, cur, direction))",
"- # 壁か黒マスはスキップ",
"- if field[nxt[0]][nxt[1]] == \"*\" or field[nxt[0]][nxt[1]] == \"#\":",
"- continue",
"- # 現在位置+1の距離を移動先に記録",
"- if (",
"- field[nxt[0]][nxt[1]] == \".\"",
"- and memo[nxt[0]][nxt[1]] > memo[cur[0]][cur[1]] + 1",
"- ):",
"- memo[nxt[0]][nxt[1]] = memo[cur[0]][cur[1]] + 1",
"- # ここで移動元のマスを記録",
"- prevs[nxt[0]][nxt[1]] = (cur[0], cur[1])",
"- # キューに次のマスを足す",
"- que.append(nxt)",
"+def list2d(a, b, c):",
"+ return [[c] * b for i in range(a)]",
"-# 最短経路を出す",
"-bfs()",
"-# ゴールに辿り着けない場合",
"-if memo[goal[0]][goal[1]] == float(\"inf\"):",
"+def list3d(a, b, c, d):",
"+ return [[[d] * c for j in range(b)] for i in range(a)]",
"+",
"+",
"+def list4d(a, b, c, d, e):",
"+ return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]",
"+",
"+",
"+def ceil(x, y=1):",
"+ return int(-(-x // y))",
"+",
"+",
"+def INT():",
"+ return int(eval(input()))",
"+",
"+",
"+def MAP():",
"+ return list(map(int, input().split()))",
"+",
"+",
"+def LIST(N=None):",
"+ return list(MAP()) if N is None else [INT() for i in range(N)]",
"+",
"+",
"+def Yes():",
"+ print(\"Yes\")",
"+",
"+",
"+def No():",
"+ print(\"No\")",
"+",
"+",
"+def YES():",
"+ print(\"YES\")",
"+",
"+",
"+def NO():",
"+ print(\"NO\")",
"+",
"+",
"+sys.setrecursionlimit(10**9)",
"+INF = 10**18",
"+MOD = 10**9 + 7",
"+",
"+",
"+def build_grid(H, W, intv, _type, space=True, padding=False):",
"+ # 入力がスペース区切りかどうか",
"+ if space:",
"+ _input = lambda: input().split()",
"+ else:",
"+ _input = lambda: eval(input())",
"+ _list = lambda: list(map(_type, _input()))",
"+ # 余白の有無",
"+ if padding:",
"+ offset = 1",
"+ else:",
"+ offset = 0",
"+ grid = list2d(H + offset * 2, W + offset * 2, intv)",
"+ for i in range(offset, H + offset):",
"+ row = _list()",
"+ for j in range(offset, W + offset):",
"+ grid[i][j] = row[j - offset]",
"+ return grid",
"+",
"+",
"+H, W = MAP()",
"+grid = build_grid(H, W, \"#\", str, space=False, padding=True)",
"+# グリッドBFS",
"+directions = ((1, 0), (-1, 0), (0, 1), (0, -1))",
"+que = deque([(1, 1, 0)])",
"+dist = list2d(H + 2, W + 2, INF)",
"+while que:",
"+ h, w, c = que.popleft()",
"+ if dist[h][w] != INF:",
"+ continue",
"+ dist[h][w] = c",
"+ for dh, dw in directions:",
"+ h2 = h + dh",
"+ w2 = w + dw",
"+ if grid[h2][w2] == \"#\":",
"+ continue",
"+ que.append((h2, w2, c + 1))",
"+# ゴール到達不可",
"+if dist[H][W] == INF:",
"-# 最短経路で使うマスに目印をつける",
"-field[goal[0]][goal[1]] = \"@\"",
"-nxt = prevs[goal[0]][goal[1]]",
"-for _ in range(memo[goal[0]][goal[1]]):",
"- field[nxt[0]][nxt[1]] = \"@\"",
"- nxt = prevs[nxt[0]][nxt[1]]",
"-# 残っている白マスが塗り替えられる場所",
"+# 経路復元",
"+que = deque([(H, W)])",
"+while que:",
"+ h, w = que.popleft()",
"+ grid[h][w] = \"@\"",
"+ for dh, dw in directions:",
"+ h2 = h + dh",
"+ w2 = w + dw",
"+ if dist[h2][w2] == dist[h][w] - 1:",
"+ que.append((h2, w2))",
"+ break",
"+# 最短経路で通る場所以外をカウント",
"- if field[i][j] == \".\":",
"+ if grid[i][j] == \".\":"
] | false | 0.064729 | 0.048508 | 1.334407 | [
"s574761333",
"s284426781"
] |
u525065967 | p02550 | python | s486889450 | s453619268 | 56 | 51 | 13,476 | 13,400 | Accepted | Accepted | 8.93 | n, x, m = list(map(int, input().split()))
mn = min(n, m)
P = [] # value of pre & cycle
sum_p = 0 # sum of pre + cycle
X = [-1] * m # for cycle check
for i in range(mn):
if X[x] > -1:
cyc_len = len(P) - X[x]
nxt_len = (n - X[x]) % cyc_len
pre = sum(P[:X[x]])
cyc = (sum_p - pre) * ((n - X[x]) // cyc_len)
nxt = sum(P[X[x]: X[x] + nxt_len])
print((pre + cyc + nxt))
exit()
X[x] = i
P.append(x)
sum_p += x
x = x*x % m
print(sum_p)
| n, x, m = list(map(int, input().split()))
P = [] # value of pre & cycle
sum_p = 0 # sum of pre + cycle
X = [-1] * m # for cycle check
for i in range(n):
if X[x] > -1:
cyc_len = len(P) - X[x]
nxt_len = (n - X[x]) % cyc_len
pre = sum(P[:X[x]])
cyc = (sum_p - pre) * ((n - X[x]) // cyc_len)
nxt = sum(P[X[x]: X[x] + nxt_len])
print((pre + cyc + nxt))
exit()
X[x] = i
P.append(x)
sum_p += x
x = x*x % m
print(sum_p)
| 19 | 18 | 514 | 497 | n, x, m = list(map(int, input().split()))
mn = min(n, m)
P = [] # value of pre & cycle
sum_p = 0 # sum of pre + cycle
X = [-1] * m # for cycle check
for i in range(mn):
if X[x] > -1:
cyc_len = len(P) - X[x]
nxt_len = (n - X[x]) % cyc_len
pre = sum(P[: X[x]])
cyc = (sum_p - pre) * ((n - X[x]) // cyc_len)
nxt = sum(P[X[x] : X[x] + nxt_len])
print((pre + cyc + nxt))
exit()
X[x] = i
P.append(x)
sum_p += x
x = x * x % m
print(sum_p)
| n, x, m = list(map(int, input().split()))
P = [] # value of pre & cycle
sum_p = 0 # sum of pre + cycle
X = [-1] * m # for cycle check
for i in range(n):
if X[x] > -1:
cyc_len = len(P) - X[x]
nxt_len = (n - X[x]) % cyc_len
pre = sum(P[: X[x]])
cyc = (sum_p - pre) * ((n - X[x]) // cyc_len)
nxt = sum(P[X[x] : X[x] + nxt_len])
print((pre + cyc + nxt))
exit()
X[x] = i
P.append(x)
sum_p += x
x = x * x % m
print(sum_p)
| false | 5.263158 | [
"-mn = min(n, m)",
"-for i in range(mn):",
"+for i in range(n):"
] | false | 0.045409 | 0.045755 | 0.992435 | [
"s486889450",
"s453619268"
] |
u803617136 | p02761 | python | s170054565 | s010393911 | 177 | 18 | 38,256 | 3,060 | Accepted | Accepted | 89.83 | import math
N, M = list(map(int, input().split()))
candidate = []
for i in range(1000):
if N == len(str(i)):
candidate.append(i)
for _ in range(M):
s, c = list(map(int, input().split()))
tmp = []
for n in candidate:
if int(str(n)[s - 1]) == c:
tmp.append(n)
candidate = tmp
if candidate:
print((candidate[0]))
else:
print((-1)) | n, m = list(map(int, input().split()))
nums = []
for i in range(1000):
if len(str(i)) == n:
nums.append(i)
for _ in range(m):
s, c = list(map(int, input().split()))
next_nums = []
for a in nums:
if int(str(a)[s - 1]) == c:
next_nums.append(a)
nums = next_nums
print((nums[0] if nums else -1))
| 21 | 15 | 391 | 343 | import math
N, M = list(map(int, input().split()))
candidate = []
for i in range(1000):
if N == len(str(i)):
candidate.append(i)
for _ in range(M):
s, c = list(map(int, input().split()))
tmp = []
for n in candidate:
if int(str(n)[s - 1]) == c:
tmp.append(n)
candidate = tmp
if candidate:
print((candidate[0]))
else:
print((-1))
| n, m = list(map(int, input().split()))
nums = []
for i in range(1000):
if len(str(i)) == n:
nums.append(i)
for _ in range(m):
s, c = list(map(int, input().split()))
next_nums = []
for a in nums:
if int(str(a)[s - 1]) == c:
next_nums.append(a)
nums = next_nums
print((nums[0] if nums else -1))
| false | 28.571429 | [
"-import math",
"-",
"-N, M = list(map(int, input().split()))",
"-candidate = []",
"+n, m = list(map(int, input().split()))",
"+nums = []",
"- if N == len(str(i)):",
"- candidate.append(i)",
"-for _ in range(M):",
"+ if len(str(i)) == n:",
"+ nums.append(i)",
"+for _ in range(m):",
"- tmp = []",
"- for n in candidate:",
"- if int(str(n)[s - 1]) == c:",
"- tmp.append(n)",
"- candidate = tmp",
"-if candidate:",
"- print((candidate[0]))",
"-else:",
"- print((-1))",
"+ next_nums = []",
"+ for a in nums:",
"+ if int(str(a)[s - 1]) == c:",
"+ next_nums.append(a)",
"+ nums = next_nums",
"+print((nums[0] if nums else -1))"
] | false | 0.130158 | 0.044516 | 2.923844 | [
"s170054565",
"s010393911"
] |
u738898077 | p04045 | python | s396824959 | s524825393 | 186 | 54 | 3,060 | 3,060 | Accepted | Accepted | 70.97 | n,k = list(map(int,input().split()))
dls = list(map(int,input().split()))
while 1:
s = list(map(int,list(str(n))))
for i in dls:
if i in s:
break
else:
print(n)
exit()
n += 1 | n,k = list(map(int,input().split()))
dls = list(map(str,input().split()))
while 1:
s = str(n)
for i in dls:
if i in s:
break
else:
print(n)
exit()
n += 1 | 11 | 11 | 230 | 209 | n, k = list(map(int, input().split()))
dls = list(map(int, input().split()))
while 1:
s = list(map(int, list(str(n))))
for i in dls:
if i in s:
break
else:
print(n)
exit()
n += 1
| n, k = list(map(int, input().split()))
dls = list(map(str, input().split()))
while 1:
s = str(n)
for i in dls:
if i in s:
break
else:
print(n)
exit()
n += 1
| false | 0 | [
"-dls = list(map(int, input().split()))",
"+dls = list(map(str, input().split()))",
"- s = list(map(int, list(str(n))))",
"+ s = str(n)"
] | false | 0.00767 | 0.070424 | 0.108915 | [
"s396824959",
"s524825393"
] |
u495267515 | p03698 | python | s654019069 | s850601409 | 53 | 49 | 5,328 | 5,192 | Accepted | Accepted | 7.55 | # -*- coding: utf-8 -*-
import sys
import subprocess
import json
import time
import math
import re
import sqlite3
S = eval(input())
dic = {}
for c in S:
if c in dic:
print("no")
exit(0)
dic[c] = 1
print("yes")
| # -*- coding: utf-8 -*-
import sys
import subprocess
import json
import time
import math
import re
import sqlite3
S = eval(input())
if len(set(S)) == len(S): print("yes")
else: print("no")
| 20 | 15 | 251 | 201 | # -*- coding: utf-8 -*-
import sys
import subprocess
import json
import time
import math
import re
import sqlite3
S = eval(input())
dic = {}
for c in S:
if c in dic:
print("no")
exit(0)
dic[c] = 1
print("yes")
| # -*- coding: utf-8 -*-
import sys
import subprocess
import json
import time
import math
import re
import sqlite3
S = eval(input())
if len(set(S)) == len(S):
print("yes")
else:
print("no")
| false | 25 | [
"-dic = {}",
"-for c in S:",
"- if c in dic:",
"- print(\"no\")",
"- exit(0)",
"- dic[c] = 1",
"-print(\"yes\")",
"+if len(set(S)) == len(S):",
"+ print(\"yes\")",
"+else:",
"+ print(\"no\")"
] | false | 0.104828 | 0.084202 | 1.244957 | [
"s654019069",
"s850601409"
] |
u796408111 | p03556 | python | s546063536 | s888077088 | 22 | 18 | 2,940 | 2,940 | Accepted | Accepted | 18.18 | N = int(eval(input()))
ans = 1
while ans * ans <= N:
ans += 1
ans = (ans - 1) * (ans - 1)
print(ans)
| import math
N = int(eval(input()))
print((math.floor(N**0.5)**2))
| 7 | 3 | 106 | 60 | N = int(eval(input()))
ans = 1
while ans * ans <= N:
ans += 1
ans = (ans - 1) * (ans - 1)
print(ans)
| import math
N = int(eval(input()))
print((math.floor(N**0.5) ** 2))
| false | 57.142857 | [
"+import math",
"+",
"-ans = 1",
"-while ans * ans <= N:",
"- ans += 1",
"-ans = (ans - 1) * (ans - 1)",
"-print(ans)",
"+print((math.floor(N**0.5) ** 2))"
] | false | 0.036945 | 0.03681 | 1.003684 | [
"s546063536",
"s888077088"
] |
u093861603 | p02659 | python | s957014395 | s630528427 | 23 | 20 | 9,064 | 9,136 | Accepted | Accepted | 13.04 | A,B=input().split()
A=int(A)
B=int(B.replace(".",""))*100
print((A*B//10000))
| A,B=input().split()
A=int(A)
B=int(B.replace(".",""))
print((A*B//100))
| 4 | 4 | 79 | 73 | A, B = input().split()
A = int(A)
B = int(B.replace(".", "")) * 100
print((A * B // 10000))
| A, B = input().split()
A = int(A)
B = int(B.replace(".", ""))
print((A * B // 100))
| false | 0 | [
"-B = int(B.replace(\".\", \"\")) * 100",
"-print((A * B // 10000))",
"+B = int(B.replace(\".\", \"\"))",
"+print((A * B // 100))"
] | false | 0.054215 | 0.055279 | 0.980753 | [
"s957014395",
"s630528427"
] |
u588341295 | p03212 | python | s308650212 | s467061009 | 339 | 64 | 42,732 | 3,060 | Accepted | Accepted | 81.12 | # -*- coding: utf-8 -*-
from itertools import product
N = int(eval(input()))
cnt = 0
# 候補となりうる9桁までの数字を列挙
for prod in product(['0', '3', '5', '7'], repeat=9):
# チェック用に変形
num = int(''.join(prod))
s = str(num)
# 753数ではない
if (s.find('3') == -1 or s.find('5') == -1
or s.find('7') == -1 or s.find('0') != -1):
continue
# N以下ではない
if num > N:
continue
cnt += 1
print(cnt)
| # -*- coding: utf-8 -*-
"""
解説参考
再帰関数で候補の数を作っていく版
"""
N = int(eval(input()))
def dfs(s):
# N以下しかやらない
if int(s) > N:
return 0
# 753数かどうか
if '7' in s and '5' in s and '3' in s:
res = 1
else:
res = 0
# sの後ろに753を付けたもので再帰していく
for c in '753':
res += dfs(s + c)
# 最終的に自分より大きい桁で増えた分を返却していく
return res
print((dfs('0')))
| 21 | 25 | 442 | 399 | # -*- coding: utf-8 -*-
from itertools import product
N = int(eval(input()))
cnt = 0
# 候補となりうる9桁までの数字を列挙
for prod in product(["0", "3", "5", "7"], repeat=9):
# チェック用に変形
num = int("".join(prod))
s = str(num)
# 753数ではない
if s.find("3") == -1 or s.find("5") == -1 or s.find("7") == -1 or s.find("0") != -1:
continue
# N以下ではない
if num > N:
continue
cnt += 1
print(cnt)
| # -*- coding: utf-8 -*-
"""
解説参考
再帰関数で候補の数を作っていく版
"""
N = int(eval(input()))
def dfs(s):
# N以下しかやらない
if int(s) > N:
return 0
# 753数かどうか
if "7" in s and "5" in s and "3" in s:
res = 1
else:
res = 0
# sの後ろに753を付けたもので再帰していく
for c in "753":
res += dfs(s + c)
# 最終的に自分より大きい桁で増えた分を返却していく
return res
print((dfs("0")))
| false | 16 | [
"-from itertools import product",
"+\"\"\"",
"+解説参考",
"+再帰関数で候補の数を作っていく版",
"+\"\"\"",
"+N = int(eval(input()))",
"-N = int(eval(input()))",
"-cnt = 0",
"-# 候補となりうる9桁までの数字を列挙",
"-for prod in product([\"0\", \"3\", \"5\", \"7\"], repeat=9):",
"- # チェック用に変形",
"- num = int(\"\".join(prod))",
"- s = str(num)",
"- # 753数ではない",
"- if s.find(\"3\") == -1 or s.find(\"5\") == -1 or s.find(\"7\") == -1 or s.find(\"0\") != -1:",
"- continue",
"- # N以下ではない",
"- if num > N:",
"- continue",
"- cnt += 1",
"-print(cnt)",
"+",
"+def dfs(s):",
"+ # N以下しかやらない",
"+ if int(s) > N:",
"+ return 0",
"+ # 753数かどうか",
"+ if \"7\" in s and \"5\" in s and \"3\" in s:",
"+ res = 1",
"+ else:",
"+ res = 0",
"+ # sの後ろに753を付けたもので再帰していく",
"+ for c in \"753\":",
"+ res += dfs(s + c)",
"+ # 最終的に自分より大きい桁で増えた分を返却していく",
"+ return res",
"+",
"+",
"+print((dfs(\"0\")))"
] | false | 0.85144 | 0.101559 | 8.383703 | [
"s308650212",
"s467061009"
] |
u162612857 | p04020 | python | s120270268 | s100143845 | 231 | 190 | 7,200 | 7,072 | Accepted | Accepted | 17.75 |
# 直感的に分かる貪欲（下から組を作る）だと思うんだけど、これでdiff1185は数字が高すぎじゃない?
n = int(eval(input()))
nums = [int(eval(input())) for _ in range(n)]
ans = 0
for idx, m in enumerate(nums):
if m > 0:
ans += m // 2
# m -= (m // 2) * 2
m = m & 1
if m == 1 and idx != n-1 and nums[idx+1] >= 1:
ans += 1
m -= 1
nums[idx+1] -= 1
print(ans)
| # 直感的に分かる貪欲（下から組を作る）だと思うんだけど、これでdiff1185は数字が高すぎじゃない?
# 貪欲で取っていくのを考えると、非ゼロの区間が連続する場合、その連続に対して下からペアを作って、最後に0か1だけ残ることがわかり、
# 単純に書ける。こんなふうに。
n = int(eval(input()))
nums = [int(eval(input())) for _ in range(n)]
ans = 0
temp = 0
for m in nums:
if m == 0:
ans += temp // 2
temp = 0
else:
temp += m
ans += temp // 2
print(ans)
| 18 | 17 | 372 | 358 | # 直感的に分かる貪欲（下から組を作る）だと思うんだけど、これでdiff1185は数字が高すぎじゃない?
n = int(eval(input()))
nums = [int(eval(input())) for _ in range(n)]
ans = 0
for idx, m in enumerate(nums):
if m > 0:
ans += m // 2
# m -= (m // 2) * 2
m = m & 1
if m == 1 and idx != n - 1 and nums[idx + 1] >= 1:
ans += 1
m -= 1
nums[idx + 1] -= 1
print(ans)
| # 直感的に分かる貪欲（下から組を作る）だと思うんだけど、これでdiff1185は数字が高すぎじゃない?
# 貪欲で取っていくのを考えると、非ゼロの区間が連続する場合、その連続に対して下からペアを作って、最後に0か1だけ残ることがわかり、
# 単純に書ける。こんなふうに。
n = int(eval(input()))
nums = [int(eval(input())) for _ in range(n)]
ans = 0
temp = 0
for m in nums:
if m == 0:
ans += temp // 2
temp = 0
else:
temp += m
ans += temp // 2
print(ans)
| false | 5.555556 | [
"+# 貪欲で取っていくのを考えると、非ゼロの区間が連続する場合、その連続に対して下からペアを作って、最後に0か1だけ残ることがわかり、",
"+# 単純に書ける。こんなふうに。",
"-for idx, m in enumerate(nums):",
"- if m > 0:",
"- ans += m // 2",
"- # m -= (m // 2) * 2",
"- m = m & 1",
"- if m == 1 and idx != n - 1 and nums[idx + 1] >= 1:",
"- ans += 1",
"- m -= 1",
"- nums[idx + 1] -= 1",
"+temp = 0",
"+for m in nums:",
"+ if m == 0:",
"+ ans += temp // 2",
"+ temp = 0",
"+ else:",
"+ temp += m",
"+ans += temp // 2"
] | false | 0.042253 | 0.04162 | 1.015208 | [
"s120270268",
"s100143845"
] |
u006883624 | p02720 | python | s381395849 | s274996659 | 132 | 83 | 12,004 | 11,876 | Accepted | Accepted | 37.12 | from collections import deque
from heapq import heappush, heappop
def main():
K = int(eval(input()))
q = []
for i in range(1, 10):
heappush(q, i)
while True:
v = heappop(q)
K -= 1
if K == 0:
print(v)
exit()
u = v % 10
nv = v * 10 + u
heappush(q, nv)
if u == 0:
heappush(q, nv + 1)
elif u == 9:
heappush(q, nv - 1)
else:
heappush(q, nv - 1)
heappush(q, nv + 1)
main()
| from collections import deque
from collections import deque
def main():
K = int(eval(input()))
q = deque()
for i in range(1, 10):
q.append(i)
while True:
v = q.popleft()
K -= 1
if K == 0:
print(v)
exit()
u = v % 10
nv = v * 10 + u
if u == 0:
q.append(nv)
q.append(nv + 1)
elif u == 9:
q.append(nv - 1)
q.append(nv)
else:
q.append(nv - 1)
q.append(nv)
q.append(nv + 1)
main()
| 33 | 35 | 570 | 608 | from collections import deque
from heapq import heappush, heappop
def main():
K = int(eval(input()))
q = []
for i in range(1, 10):
heappush(q, i)
while True:
v = heappop(q)
K -= 1
if K == 0:
print(v)
exit()
u = v % 10
nv = v * 10 + u
heappush(q, nv)
if u == 0:
heappush(q, nv + 1)
elif u == 9:
heappush(q, nv - 1)
else:
heappush(q, nv - 1)
heappush(q, nv + 1)
main()
| from collections import deque
from collections import deque
def main():
K = int(eval(input()))
q = deque()
for i in range(1, 10):
q.append(i)
while True:
v = q.popleft()
K -= 1
if K == 0:
print(v)
exit()
u = v % 10
nv = v * 10 + u
if u == 0:
q.append(nv)
q.append(nv + 1)
elif u == 9:
q.append(nv - 1)
q.append(nv)
else:
q.append(nv - 1)
q.append(nv)
q.append(nv + 1)
main()
| false | 5.714286 | [
"-from heapq import heappush, heappop",
"+from collections import deque",
"- q = []",
"+ q = deque()",
"- heappush(q, i)",
"+ q.append(i)",
"- v = heappop(q)",
"+ v = q.popleft()",
"- heappush(q, nv)",
"- heappush(q, nv + 1)",
"+ q.append(nv)",
"+ q.append(nv + 1)",
"- heappush(q, nv - 1)",
"+ q.append(nv - 1)",
"+ q.append(nv)",
"- heappush(q, nv - 1)",
"- heappush(q, nv + 1)",
"+ q.append(nv - 1)",
"+ q.append(nv)",
"+ q.append(nv + 1)"
] | false | 0.118009 | 0.04312 | 2.736788 | [
"s381395849",
"s274996659"
] |
u760802228 | p03470 | python | s618171237 | s650060197 | 20 | 18 | 3,060 | 2,940 | Accepted | Accepted | 10 | _, *d = open(0).read().split()
print((len(set(d)))) | _, *d = open(0)
print((len(set(d)))) | 2 | 2 | 50 | 35 | _, *d = open(0).read().split()
print((len(set(d))))
| _, *d = open(0)
print((len(set(d))))
| false | 0 | [
"-_, *d = open(0).read().split()",
"+_, *d = open(0)"
] | false | 0.007553 | 0.106558 | 0.070885 | [
"s618171237",
"s650060197"
] |
u994988729 | p03175 | python | s772269373 | s100182538 | 723 | 609 | 114,004 | 30,248 | Accepted | Accepted | 15.77 | #EDPC P_Independent_Set
import sys
input = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 7)
N = int(eval(input()))
edge = [[] for _ in range(N + 1)]
mod = 10 ** 9 + 7
for _ in range(N - 1):
a, b = list(map(int, input().split()))
edge[a].append(b)
edge[b].append(a)
root = 1
black = [1] * (N + 1)
white = [1] * (N + 1)
under = [[] for _ in range(N+1)]
seen = [False] * (N + 1)
#節点iの子のリストを作成
node = [root]
while node:
s = node.pop()
seen[s] = True
for t in edge[s]:
if seen[t]:
continue
node.append(t)
under[s].append(t)
def BW(s):
if not under[s]: #葉なら白黒1色ずつ
return
for t in under[s]:
BW(t)
white[s] = (white[s] * (white[t] + black[t])) % mod
black[s] = (black[s] * white[t]) % mod
BW(root)
ans = white[root]+black[root]
print((ans%mod))
| from collections import deque
N = int(eval(input()))
edge = [[] for _ in range(N + 1)]
for _ in range(N - 1):
x, y = list(map(int, input().split()))
edge[x].append(y)
edge[y].append(x)
mod = 10 ** 9 + 7
parent = [-1] * (N + 1)
node = deque([1])
ts = []
while node:
s = node.popleft()
ts.append(s)
for t in edge[s]:
if t == parent[s]:
continue
parent[t] = s
node.append(t)
black = [1] * (N + 1)
white = [1] * (N + 1)
while ts:
s = ts.pop()
b = 1
w = 1
for t in edge[s]:
if parent[s] == t:
continue
b = b * white[t] % mod
w = w * (white[t] + black[t]) % mod
black[s] = b
white[s] = w
print(((black[1] + white[1]) % mod)) | 46 | 38 | 894 | 766 | # EDPC P_Independent_Set
import sys
input = sys.stdin.buffer.readline
sys.setrecursionlimit(10**7)
N = int(eval(input()))
edge = [[] for _ in range(N + 1)]
mod = 10**9 + 7
for _ in range(N - 1):
a, b = list(map(int, input().split()))
edge[a].append(b)
edge[b].append(a)
root = 1
black = [1] * (N + 1)
white = [1] * (N + 1)
under = [[] for _ in range(N + 1)]
seen = [False] * (N + 1)
# 節点iの子のリストを作成
node = [root]
while node:
s = node.pop()
seen[s] = True
for t in edge[s]:
if seen[t]:
continue
node.append(t)
under[s].append(t)
def BW(s):
if not under[s]: # 葉なら白黒1色ずつ
return
for t in under[s]:
BW(t)
white[s] = (white[s] * (white[t] + black[t])) % mod
black[s] = (black[s] * white[t]) % mod
BW(root)
ans = white[root] + black[root]
print((ans % mod))
| from collections import deque
N = int(eval(input()))
edge = [[] for _ in range(N + 1)]
for _ in range(N - 1):
x, y = list(map(int, input().split()))
edge[x].append(y)
edge[y].append(x)
mod = 10**9 + 7
parent = [-1] * (N + 1)
node = deque([1])
ts = []
while node:
s = node.popleft()
ts.append(s)
for t in edge[s]:
if t == parent[s]:
continue
parent[t] = s
node.append(t)
black = [1] * (N + 1)
white = [1] * (N + 1)
while ts:
s = ts.pop()
b = 1
w = 1
for t in edge[s]:
if parent[s] == t:
continue
b = b * white[t] % mod
w = w * (white[t] + black[t]) % mod
black[s] = b
white[s] = w
print(((black[1] + white[1]) % mod))
| false | 17.391304 | [
"-# EDPC P_Independent_Set",
"-import sys",
"+from collections import deque",
"-input = sys.stdin.buffer.readline",
"-sys.setrecursionlimit(10**7)",
"+for _ in range(N - 1):",
"+ x, y = list(map(int, input().split()))",
"+ edge[x].append(y)",
"+ edge[y].append(x)",
"-for _ in range(N - 1):",
"- a, b = list(map(int, input().split()))",
"- edge[a].append(b)",
"- edge[b].append(a)",
"-root = 1",
"+parent = [-1] * (N + 1)",
"+node = deque([1])",
"+ts = []",
"+while node:",
"+ s = node.popleft()",
"+ ts.append(s)",
"+ for t in edge[s]:",
"+ if t == parent[s]:",
"+ continue",
"+ parent[t] = s",
"+ node.append(t)",
"-under = [[] for _ in range(N + 1)]",
"-seen = [False] * (N + 1)",
"-# 節点iの子のリストを作成",
"-node = [root]",
"-while node:",
"- s = node.pop()",
"- seen[s] = True",
"+while ts:",
"+ s = ts.pop()",
"+ b = 1",
"+ w = 1",
"- if seen[t]:",
"+ if parent[s] == t:",
"- node.append(t)",
"- under[s].append(t)",
"-",
"-",
"-def BW(s):",
"- if not under[s]: # 葉なら白黒1色ずつ",
"- return",
"- for t in under[s]:",
"- BW(t)",
"- white[s] = (white[s] * (white[t] + black[t])) % mod",
"- black[s] = (black[s] * white[t]) % mod",
"-",
"-",
"-BW(root)",
"-ans = white[root] + black[root]",
"-print((ans % mod))",
"+ b = b * white[t] % mod",
"+ w = w * (white[t] + black[t]) % mod",
"+ black[s] = b",
"+ white[s] = w",
"+print(((black[1] + white[1]) % mod))"
] | false | 0.041638 | 0.041882 | 0.994188 | [
"s772269373",
"s100182538"
] |
u634079249 | p02881 | python | s033374434 | s135763775 | 202 | 114 | 3,064 | 3,064 | Accepted | Accepted | 43.56 | import sys
import os
import math
def main():
if os.getenv("LOCAL"):
sys.stdin = open("input.txt", "r")
N = int(sys.stdin.readline().rstrip())
max = int(math.sqrt(N) + 1)
ret = float('inf')
for i in range(1, max):
q, mod = divmod(N, i)
if mod == 0:
j = N // i
ret = min(ret, ((j-1)+(i-1)))
print(ret)
if __name__ == '__main__':
main()
| import sys
import os
import math
ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]
iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]
def main():
if os.getenv("LOCAL"):
sys.stdin = open("input.txt", "r")
N = ii()
T = int(math.sqrt(N))
ret = float('inf')
for i in range(1, T+1):
if N % i == 0:
ret = min(ret, N//i+i-2)
print(ret)
if __name__ == '__main__':
main()
| 23 | 27 | 438 | 691 | import sys
import os
import math
def main():
if os.getenv("LOCAL"):
sys.stdin = open("input.txt", "r")
N = int(sys.stdin.readline().rstrip())
max = int(math.sqrt(N) + 1)
ret = float("inf")
for i in range(1, max):
q, mod = divmod(N, i)
if mod == 0:
j = N // i
ret = min(ret, ((j - 1) + (i - 1)))
print(ret)
if __name__ == "__main__":
main()
| import sys
import os
import math
ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]
iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]
def main():
if os.getenv("LOCAL"):
sys.stdin = open("input.txt", "r")
N = ii()
T = int(math.sqrt(N))
ret = float("inf")
for i in range(1, T + 1):
if N % i == 0:
ret = min(ret, N // i + i - 2)
print(ret)
if __name__ == "__main__":
main()
| false | 14.814815 | [
"+",
"+ii = lambda: int(sys.stdin.buffer.readline().rstrip())",
"+il = lambda: list(map(int, sys.stdin.buffer.readline().split()))",
"+iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]",
"+iss = lambda: sys.stdin.buffer.readline().decode().rstrip()",
"+isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]",
"- N = int(sys.stdin.readline().rstrip())",
"- max = int(math.sqrt(N) + 1)",
"+ N = ii()",
"+ T = int(math.sqrt(N))",
"- for i in range(1, max):",
"- q, mod = divmod(N, i)",
"- if mod == 0:",
"- j = N // i",
"- ret = min(ret, ((j - 1) + (i - 1)))",
"+ for i in range(1, T + 1):",
"+ if N % i == 0:",
"+ ret = min(ret, N // i + i - 2)"
] | false | 0.036984 | 0.037709 | 0.980784 | [
"s033374434",
"s135763775"
] |
u422104747 | p03141 | python | s460217745 | s577352423 | 1,205 | 844 | 84,056 | 59,640 | Accepted | Accepted | 29.96 | n=int(eval(input()))
taka=[]
ao=[]
s=set()
for i in range(n):
a,b=list(map(int,input().split()))
taka.append([a+b,a,i])
ao.append([a+b,b,i])
s.add(i)
taka.sort(reverse=True)
ao.sort(reverse=True)
takapt=0
takaind=0
aopt=0
aoind=0
while len(s)>0:
while taka[takaind][2] not in s:
takaind+=1
s.remove(taka[takaind][2])
takapt+=taka[takaind][1]
if len(s)==0:
break
while ao[aoind][2] not in s:
aoind+=1
s.remove(ao[aoind][2])
aopt+=ao[aoind][1]
print((takapt-aopt))
| n=int(eval(input()))
l=[]
for i in range(n):
a,b=list(map(int,input().split()))
l.append([a+b,a,b])
l.sort(reverse=True)
t=0
a=0
for i in range(n):
if i%2==0:
t+=l[i][1]
else:
a+=l[i][2]
print((t-a))
| 27 | 15 | 543 | 233 | n = int(eval(input()))
taka = []
ao = []
s = set()
for i in range(n):
a, b = list(map(int, input().split()))
taka.append([a + b, a, i])
ao.append([a + b, b, i])
s.add(i)
taka.sort(reverse=True)
ao.sort(reverse=True)
takapt = 0
takaind = 0
aopt = 0
aoind = 0
while len(s) > 0:
while taka[takaind][2] not in s:
takaind += 1
s.remove(taka[takaind][2])
takapt += taka[takaind][1]
if len(s) == 0:
break
while ao[aoind][2] not in s:
aoind += 1
s.remove(ao[aoind][2])
aopt += ao[aoind][1]
print((takapt - aopt))
| n = int(eval(input()))
l = []
for i in range(n):
a, b = list(map(int, input().split()))
l.append([a + b, a, b])
l.sort(reverse=True)
t = 0
a = 0
for i in range(n):
if i % 2 == 0:
t += l[i][1]
else:
a += l[i][2]
print((t - a))
| false | 44.444444 | [
"-taka = []",
"-ao = []",
"-s = set()",
"+l = []",
"- taka.append([a + b, a, i])",
"- ao.append([a + b, b, i])",
"- s.add(i)",
"-taka.sort(reverse=True)",
"-ao.sort(reverse=True)",
"-takapt = 0",
"-takaind = 0",
"-aopt = 0",
"-aoind = 0",
"-while len(s) > 0:",
"- while taka[takaind][2] not in s:",
"- takaind += 1",
"- s.remove(taka[takaind][2])",
"- takapt += taka[takaind][1]",
"- if len(s) == 0:",
"- break",
"- while ao[aoind][2] not in s:",
"- aoind += 1",
"- s.remove(ao[aoind][2])",
"- aopt += ao[aoind][1]",
"-print((takapt - aopt))",
"+ l.append([a + b, a, b])",
"+l.sort(reverse=True)",
"+t = 0",
"+a = 0",
"+for i in range(n):",
"+ if i % 2 == 0:",
"+ t += l[i][1]",
"+ else:",
"+ a += l[i][2]",
"+print((t - a))"
] | false | 0.046809 | 0.041436 | 1.129672 | [
"s460217745",
"s577352423"
] |
u515740713 | p02647 | python | s225139897 | s802886965 | 1,560 | 1,046 | 129,368 | 126,364 | Accepted | Accepted | 32.95 | import sys
import numpy as np
from numba import jit
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N, K, *A = list(map(int, read().split()))
@jit
def imos(A):
B = np.zeros_like(A)
for i,x in enumerate(A):
a = max(0,i-x)
b = min(N-1,i+x)
B[a] += 1
if b+1 <= N-1:
B[b+1] -= 1
B = np.cumsum(B)
return B
for i in range(K):
if i >= 50:
break
A = imos(A)
print((*A)) | import sys
import numpy as np
from numba import jit
readline = sys.stdin.readline
@jit
def loop(n,k,a):
for j in range(k):
b = np.zeros(n+1, dtype=np.int64)
for i in range(n):
b[max(i-a[i], 0)] += 1
b[min(i+a[i]+1, n)] -= 1
a = np.cumsum(b)[:-1]
if np.all(a==n):
return(a)
break
else:
return(a)
n, k = list(map(int, readline().split()))
a = np.array(readline().split(), dtype=np.int64)
ans = loop(n,k,a)
print((*ans)) | 25 | 26 | 476 | 540 | import sys
import numpy as np
from numba import jit
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N, K, *A = list(map(int, read().split()))
@jit
def imos(A):
B = np.zeros_like(A)
for i, x in enumerate(A):
a = max(0, i - x)
b = min(N - 1, i + x)
B[a] += 1
if b + 1 <= N - 1:
B[b + 1] -= 1
B = np.cumsum(B)
return B
for i in range(K):
if i >= 50:
break
A = imos(A)
print((*A))
| import sys
import numpy as np
from numba import jit
readline = sys.stdin.readline
@jit
def loop(n, k, a):
for j in range(k):
b = np.zeros(n + 1, dtype=np.int64)
for i in range(n):
b[max(i - a[i], 0)] += 1
b[min(i + a[i] + 1, n)] -= 1
a = np.cumsum(b)[:-1]
if np.all(a == n):
return a
break
else:
return a
n, k = list(map(int, readline().split()))
a = np.array(readline().split(), dtype=np.int64)
ans = loop(n, k, a)
print((*ans))
| false | 3.846154 | [
"-read = sys.stdin.buffer.read",
"-readline = sys.stdin.buffer.readline",
"-readlines = sys.stdin.buffer.readlines",
"-N, K, *A = list(map(int, read().split()))",
"+readline = sys.stdin.readline",
"-def imos(A):",
"- B = np.zeros_like(A)",
"- for i, x in enumerate(A):",
"- a = max(0, i - x)",
"- b = min(N - 1, i + x)",
"- B[a] += 1",
"- if b + 1 <= N - 1:",
"- B[b + 1] -= 1",
"- B = np.cumsum(B)",
"- return B",
"+def loop(n, k, a):",
"+ for j in range(k):",
"+ b = np.zeros(n + 1, dtype=np.int64)",
"+ for i in range(n):",
"+ b[max(i - a[i], 0)] += 1",
"+ b[min(i + a[i] + 1, n)] -= 1",
"+ a = np.cumsum(b)[:-1]",
"+ if np.all(a == n):",
"+ return a",
"+ break",
"+ else:",
"+ return a",
"-for i in range(K):",
"- if i >= 50:",
"- break",
"- A = imos(A)",
"-print((*A))",
"+n, k = list(map(int, readline().split()))",
"+a = np.array(readline().split(), dtype=np.int64)",
"+ans = loop(n, k, a)",
"+print((*ans))"
] | false | 0.233824 | 0.280049 | 0.834938 | [
"s225139897",
"s802886965"
] |
u759412327 | p02911 | python | s057795376 | s717335446 | 193 | 178 | 11,500 | 15,540 | Accepted | Accepted | 7.77 | N,K,Q = list(map(int,input().split()))
P = N*[K-Q]
for q in range(Q):
a = int(eval(input()))
P[a-1]+=1
for n in range(N):
if P[n]<=0:
print("No")
else:
print("Yes") | N,K,Q = list(map(int,input().split()))
A = [int(eval(input())) for q in range(Q)]
P = N*[K-Q]
for a in A:
P[a-1]+=1
for n in range(N):
if P[n]<=0:
print("No")
else:
print("Yes") | 12 | 12 | 181 | 192 | N, K, Q = list(map(int, input().split()))
P = N * [K - Q]
for q in range(Q):
a = int(eval(input()))
P[a - 1] += 1
for n in range(N):
if P[n] <= 0:
print("No")
else:
print("Yes")
| N, K, Q = list(map(int, input().split()))
A = [int(eval(input())) for q in range(Q)]
P = N * [K - Q]
for a in A:
P[a - 1] += 1
for n in range(N):
if P[n] <= 0:
print("No")
else:
print("Yes")
| false | 0 | [
"+A = [int(eval(input())) for q in range(Q)]",
"-for q in range(Q):",
"- a = int(eval(input()))",
"+for a in A:"
] | false | 0.03482 | 0.036966 | 0.941951 | [
"s057795376",
"s717335446"
] |
u581040514 | p03681 | python | s132921601 | s992564637 | 49 | 43 | 3,064 | 3,064 | Accepted | Accepted | 12.24 | N, M = [int(_) for _ in input().split()]
mod = 10**9+7
if N < M:
N, M = M, N
if N == M:
answer = 2
for i in range(2, N+1):
answer = answer * i * i
answer = answer % mod
print (answer)
elif N == M+1:
answer = 1
for i in range(2, N):
answer = answer * i * i
answer = answer % mod
answer = answer * N % mod
print(answer)
else:
print((0)) | N, M = [int(_) for _ in input().split()]
mod = 10**9+7
if N < M:
N, M = M, N
if N == M:
answer = 1
for i in range(2, N+1):
answer = answer * i
answer = answer % mod
answer = answer**2 * 2 % mod
print (answer)
elif N == M+1:
answer = 1
for i in range(2, M+1):
answer = answer * i
answer = answer % mod
answer = answer**2 * N % mod
print(answer)
else:
print((0)) | 23 | 24 | 378 | 404 | N, M = [int(_) for _ in input().split()]
mod = 10**9 + 7
if N < M:
N, M = M, N
if N == M:
answer = 2
for i in range(2, N + 1):
answer = answer * i * i
answer = answer % mod
print(answer)
elif N == M + 1:
answer = 1
for i in range(2, N):
answer = answer * i * i
answer = answer % mod
answer = answer * N % mod
print(answer)
else:
print((0))
| N, M = [int(_) for _ in input().split()]
mod = 10**9 + 7
if N < M:
N, M = M, N
if N == M:
answer = 1
for i in range(2, N + 1):
answer = answer * i
answer = answer % mod
answer = answer**2 * 2 % mod
print(answer)
elif N == M + 1:
answer = 1
for i in range(2, M + 1):
answer = answer * i
answer = answer % mod
answer = answer**2 * N % mod
print(answer)
else:
print((0))
| false | 4.166667 | [
"- answer = 2",
"+ answer = 1",
"- answer = answer * i * i",
"+ answer = answer * i",
"+ answer = answer**2 * 2 % mod",
"- for i in range(2, N):",
"- answer = answer * i * i",
"+ for i in range(2, M + 1):",
"+ answer = answer * i",
"- answer = answer * N % mod",
"+ answer = answer**2 * N % mod"
] | false | 0.123807 | 0.110046 | 1.125055 | [
"s132921601",
"s992564637"
] |
u062147869 | p03801 | python | s463851620 | s743919102 | 468 | 430 | 85,736 | 77,924 | Accepted | Accepted | 8.12 | from collections import defaultdict
import sys
class BIT():
def __init__(self, number):
self.n = number
self.list = [0] * (number + 1)
def add(self, i, x): # ith added x 1indexed
while i <= self.n:
self.list[i] += x
i += i & -i
def search(self, i): # 1-i sum
s = 0
while i > 0:
s += self.list[i]
i -= i & -i
return s
def suma(self, i, j): # i,i+1,..j sum
return self.search(j) - self.search(i - 1)
N=int(eval(input()))
A=[int(i) for i in input().split()]
C=sorted(set(A))
ndd=defaultdict(int)
for i in range(len(C)):
ndd[i+1]=C[i]
dd=defaultdict(int)
for i in range(len(C)):
dd[C[i]]=i+1
#print(ndd,dd)
visit=[0]*N
visit[0]=1
s=A[0]
H=[]
H.append(s)
for i in range(1,N):
if s<A[i]:
s=A[i]
H.append(s)
visit[i]=1
BITI=BIT(N+1)
BITI2=BIT(N+1)
j=len(H)-1
l=dd[H[j]]
num=sum(A)
T=[0]*N
ans=0
for i in range(N-1,-1,-1):
if l==dd[A[0]]:
break
BITI.add(dd[A[i]],A[i])
BITI2.add(dd[A[i]],1)
if dd[A[i]]==l and visit[i]==1:
T[i]=BITI.suma(dd[H[j-1]],N+1)-BITI2.suma(dd[H[j-1]],N+1)*H[j-1]-ans
ans+=T[i]
#print(i,j,l,T[i],ans)
j-=1
l=dd[H[j]]
x=num-sum(T)
T[0]=x
#print(visit,T)
for t in T:
print(t)
| from operator import itemgetter
import sys
N=int(eval(input()))
A=[int(i) for i in input().split()]
B=[(A[i],i) for i in range(N)]
B=sorted(B,key=itemgetter(1))
B=sorted(B,key=itemgetter(0))
T=[0]*N
cos,pt=B.pop()
for i in range(1,N):
cos2,pt2=B.pop()
T[pt]+=(cos-cos2)*i
pt=min(pt,pt2)
cos=cos2
T[pt]+=cos*N
for i in T:
print(i)
| 70 | 17 | 1,390 | 360 | from collections import defaultdict
import sys
class BIT:
def __init__(self, number):
self.n = number
self.list = [0] * (number + 1)
def add(self, i, x): # ith added x 1indexed
while i <= self.n:
self.list[i] += x
i += i & -i
def search(self, i): # 1-i sum
s = 0
while i > 0:
s += self.list[i]
i -= i & -i
return s
def suma(self, i, j): # i,i+1,..j sum
return self.search(j) - self.search(i - 1)
N = int(eval(input()))
A = [int(i) for i in input().split()]
C = sorted(set(A))
ndd = defaultdict(int)
for i in range(len(C)):
ndd[i + 1] = C[i]
dd = defaultdict(int)
for i in range(len(C)):
dd[C[i]] = i + 1
# print(ndd,dd)
visit = [0] * N
visit[0] = 1
s = A[0]
H = []
H.append(s)
for i in range(1, N):
if s < A[i]:
s = A[i]
H.append(s)
visit[i] = 1
BITI = BIT(N + 1)
BITI2 = BIT(N + 1)
j = len(H) - 1
l = dd[H[j]]
num = sum(A)
T = [0] * N
ans = 0
for i in range(N - 1, -1, -1):
if l == dd[A[0]]:
break
BITI.add(dd[A[i]], A[i])
BITI2.add(dd[A[i]], 1)
if dd[A[i]] == l and visit[i] == 1:
T[i] = (
BITI.suma(dd[H[j - 1]], N + 1)
- BITI2.suma(dd[H[j - 1]], N + 1) * H[j - 1]
- ans
)
ans += T[i]
# print(i,j,l,T[i],ans)
j -= 1
l = dd[H[j]]
x = num - sum(T)
T[0] = x
# print(visit,T)
for t in T:
print(t)
| from operator import itemgetter
import sys
N = int(eval(input()))
A = [int(i) for i in input().split()]
B = [(A[i], i) for i in range(N)]
B = sorted(B, key=itemgetter(1))
B = sorted(B, key=itemgetter(0))
T = [0] * N
cos, pt = B.pop()
for i in range(1, N):
cos2, pt2 = B.pop()
T[pt] += (cos - cos2) * i
pt = min(pt, pt2)
cos = cos2
T[pt] += cos * N
for i in T:
print(i)
| false | 75.714286 | [
"-from collections import defaultdict",
"+from operator import itemgetter",
"-",
"-",
"-class BIT:",
"- def __init__(self, number):",
"- self.n = number",
"- self.list = [0] * (number + 1)",
"-",
"- def add(self, i, x): # ith added x 1indexed",
"- while i <= self.n:",
"- self.list[i] += x",
"- i += i & -i",
"-",
"- def search(self, i): # 1-i sum",
"- s = 0",
"- while i > 0:",
"- s += self.list[i]",
"- i -= i & -i",
"- return s",
"-",
"- def suma(self, i, j): # i,i+1,..j sum",
"- return self.search(j) - self.search(i - 1)",
"-",
"-C = sorted(set(A))",
"-ndd = defaultdict(int)",
"-for i in range(len(C)):",
"- ndd[i + 1] = C[i]",
"-dd = defaultdict(int)",
"-for i in range(len(C)):",
"- dd[C[i]] = i + 1",
"-# print(ndd,dd)",
"-visit = [0] * N",
"-visit[0] = 1",
"-s = A[0]",
"-H = []",
"-H.append(s)",
"+B = [(A[i], i) for i in range(N)]",
"+B = sorted(B, key=itemgetter(1))",
"+B = sorted(B, key=itemgetter(0))",
"+T = [0] * N",
"+cos, pt = B.pop()",
"- if s < A[i]:",
"- s = A[i]",
"- H.append(s)",
"- visit[i] = 1",
"-BITI = BIT(N + 1)",
"-BITI2 = BIT(N + 1)",
"-j = len(H) - 1",
"-l = dd[H[j]]",
"-num = sum(A)",
"-T = [0] * N",
"-ans = 0",
"-for i in range(N - 1, -1, -1):",
"- if l == dd[A[0]]:",
"- break",
"- BITI.add(dd[A[i]], A[i])",
"- BITI2.add(dd[A[i]], 1)",
"- if dd[A[i]] == l and visit[i] == 1:",
"- T[i] = (",
"- BITI.suma(dd[H[j - 1]], N + 1)",
"- - BITI2.suma(dd[H[j - 1]], N + 1) * H[j - 1]",
"- - ans",
"- )",
"- ans += T[i]",
"- # print(i,j,l,T[i],ans)",
"- j -= 1",
"- l = dd[H[j]]",
"-x = num - sum(T)",
"-T[0] = x",
"-# print(visit,T)",
"-for t in T:",
"- print(t)",
"+ cos2, pt2 = B.pop()",
"+ T[pt] += (cos - cos2) * i",
"+ pt = min(pt, pt2)",
"+ cos = cos2",
"+T[pt] += cos * N",
"+for i in T:",
"+ print(i)"
] | false | 0.035787 | 0.036356 | 0.984346 | [
"s463851620",
"s743919102"
] |
u136843617 | p02732 | python | s724855294 | s064402852 | 415 | 280 | 26,268 | 26,012 | Accepted | Accepted | 32.53 | n = int(input())
balls = list(map(int, input().split()))
conbi = [0]*n
for i in balls:
conbi[i-1] +=1
result = 0
for j in range(n):
result += (conbi[j]*(conbi[j]-1))//2
for k in balls:
print(result-conbi[k-1]+1, end=" ")
| def solve():
N = int(eval(input()))
A = list(map(int,input().split()))
conb = [0]*N
ans = 0
for i in A:
conb[i-1] += 1
for j in conb:
if j != 0:
ans += j*(j-1)//2
for k in range(N):
print((ans- conb[A[k]-1]+1))
if __name__ == '__main__':
solve() | 10 | 17 | 242 | 324 | n = int(input())
balls = list(map(int, input().split()))
conbi = [0] * n
for i in balls:
conbi[i - 1] += 1
result = 0
for j in range(n):
result += (conbi[j] * (conbi[j] - 1)) // 2
for k in balls:
print(result - conbi[k - 1] + 1, end=" ")
| def solve():
N = int(eval(input()))
A = list(map(int, input().split()))
conb = [0] * N
ans = 0
for i in A:
conb[i - 1] += 1
for j in conb:
if j != 0:
ans += j * (j - 1) // 2
for k in range(N):
print((ans - conb[A[k] - 1] + 1))
if __name__ == "__main__":
solve()
| false | 41.176471 | [
"-n = int(input())",
"-balls = list(map(int, input().split()))",
"-conbi = [0] * n",
"-for i in balls:",
"- conbi[i - 1] += 1",
"-result = 0",
"-for j in range(n):",
"- result += (conbi[j] * (conbi[j] - 1)) // 2",
"-for k in balls:",
"- print(result - conbi[k - 1] + 1, end=\" \")",
"+def solve():",
"+ N = int(eval(input()))",
"+ A = list(map(int, input().split()))",
"+ conb = [0] * N",
"+ ans = 0",
"+ for i in A:",
"+ conb[i - 1] += 1",
"+ for j in conb:",
"+ if j != 0:",
"+ ans += j * (j - 1) // 2",
"+ for k in range(N):",
"+ print((ans - conb[A[k] - 1] + 1))",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ solve()"
] | false | 0.051592 | 0.036307 | 1.421004 | [
"s724855294",
"s064402852"
] |
u731368968 | p02691 | python | s488556597 | s906951557 | 339 | 216 | 110,120 | 120,704 | Accepted | Accepted | 36.28 | n = int(eval(input()))
A = list(map(int, input().split()))
B = [A[i] - i for i in range(n)]
C = [-A[i] - i for i in range(n)]
# Bの要素それぞれに対するCの中ある等しいものの数の総和
C.sort()
from bisect import *
ans = 0
for b in B:
ans += bisect(C, b) - bisect_left(C, b)
print(ans)
| n = int(eval(input()))
A = list(map(int, input().split()))
C = sorted([-A[i] - i for i in range(n)])
from bisect import *
print((sum(bisect(C, b) - bisect_left(C, b) for b in [A[i] - i for i in range(n)])))
| 16 | 5 | 275 | 203 | n = int(eval(input()))
A = list(map(int, input().split()))
B = [A[i] - i for i in range(n)]
C = [-A[i] - i for i in range(n)]
# Bの要素それぞれに対するCの中ある等しいものの数の総和
C.sort()
from bisect import *
ans = 0
for b in B:
ans += bisect(C, b) - bisect_left(C, b)
print(ans)
| n = int(eval(input()))
A = list(map(int, input().split()))
C = sorted([-A[i] - i for i in range(n)])
from bisect import *
print((sum(bisect(C, b) - bisect_left(C, b) for b in [A[i] - i for i in range(n)])))
| false | 68.75 | [
"-B = [A[i] - i for i in range(n)]",
"-C = [-A[i] - i for i in range(n)]",
"-# Bの要素それぞれに対するCの中ある等しいものの数の総和",
"-C.sort()",
"+C = sorted([-A[i] - i for i in range(n)])",
"-ans = 0",
"-for b in B:",
"- ans += bisect(C, b) - bisect_left(C, b)",
"-print(ans)",
"+print((sum(bisect(C, b) - bisect_left(C, b) for b in [A[i] - i for i in range(n)])))"
] | false | 0.043244 | 0.044146 | 0.979551 | [
"s488556597",
"s906951557"
] |
u440161695 | p03487 | python | s213659743 | s165980136 | 101 | 92 | 18,672 | 20,852 | Accepted | Accepted | 8.91 | from collections import Counter
N=int(eval(input()))
A=list(map(int,input().split()))
d=Counter(A)
ans=0
for i in d:
if d[i]>=i:
ans+=d[i]-i
else:
ans+=d[i]
print(ans) | from collections import Counter
n=int(eval(input()))
a=Counter(input().split())
ans=0
for i,j in list(a.items()):
i=int(i)
if i>j:
ans+=j
elif i<j:
ans+=j-i
print(ans) | 11 | 11 | 183 | 193 | from collections import Counter
N = int(eval(input()))
A = list(map(int, input().split()))
d = Counter(A)
ans = 0
for i in d:
if d[i] >= i:
ans += d[i] - i
else:
ans += d[i]
print(ans)
| from collections import Counter
n = int(eval(input()))
a = Counter(input().split())
ans = 0
for i, j in list(a.items()):
i = int(i)
if i > j:
ans += j
elif i < j:
ans += j - i
print(ans)
| false | 0 | [
"-N = int(eval(input()))",
"-A = list(map(int, input().split()))",
"-d = Counter(A)",
"+n = int(eval(input()))",
"+a = Counter(input().split())",
"-for i in d:",
"- if d[i] >= i:",
"- ans += d[i] - i",
"- else:",
"- ans += d[i]",
"+for i, j in list(a.items()):",
"+ i = int(i)",
"+ if i > j:",
"+ ans += j",
"+ elif i < j:",
"+ ans += j - i"
] | false | 0.046516 | 0.046661 | 0.996908 | [
"s213659743",
"s165980136"
] |
u689701565 | p02682 | python | s786078045 | s446074894 | 25 | 23 | 9,176 | 9,176 | Accepted | Accepted | 8 | paramA, paramB, paramC, paramK = list([int(x) for x in input().split(' ')])
result = min(paramA, paramK)
paramK -= paramA
if paramK > 0:
paramK -= paramB
if paramK > 0:
result -= min(paramC, paramK)
print(result) | paramA, paramB, paramC, paramK = list([int(x) for x in input().split(' ')])
result = min(paramA, paramK)
paramK -= paramA
paramK -= paramB
if paramK > 0:
result -= min(paramC, paramK)
print(result) | 10 | 9 | 244 | 216 | paramA, paramB, paramC, paramK = list([int(x) for x in input().split(" ")])
result = min(paramA, paramK)
paramK -= paramA
if paramK > 0:
paramK -= paramB
if paramK > 0:
result -= min(paramC, paramK)
print(result)
| paramA, paramB, paramC, paramK = list([int(x) for x in input().split(" ")])
result = min(paramA, paramK)
paramK -= paramA
paramK -= paramB
if paramK > 0:
result -= min(paramC, paramK)
print(result)
| false | 10 | [
"+paramK -= paramB",
"- paramK -= paramB",
"- if paramK > 0:",
"- result -= min(paramC, paramK)",
"+ result -= min(paramC, paramK)"
] | false | 0.047233 | 0.043787 | 1.078698 | [
"s786078045",
"s446074894"
] |
u673173160 | p02602 | python | s332117763 | s230141533 | 168 | 148 | 96,032 | 105,544 | Accepted | Accepted | 11.9 | import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1
import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1
n, k = list(map(int, input().split()))
A = list(map(int, input().split()))
for i in range(k-1, n):
if i == k-1:
continue
else:
if A[i] > A[i-k]:
print("Yes")
else:
print("No")
#print(A[i], A[i-k]) | n, k = list(map(int, input().split()))
A = list(map(int, input().split()))
now = 1000
for i in range(k, n):
#print(A[i], A[i-k])
if A[i] > A[i-k]:
print("Yes")
else:
print("No") | 21 | 9 | 667 | 207 | import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode("utf-8")
inf = float("inf")
mod = 10**9 + 7
mans = inf
ans = 0
count = 0
pro = 1
import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode("utf-8")
inf = float("inf")
mod = 10**9 + 7
mans = inf
ans = 0
count = 0
pro = 1
n, k = list(map(int, input().split()))
A = list(map(int, input().split()))
for i in range(k - 1, n):
if i == k - 1:
continue
else:
if A[i] > A[i - k]:
print("Yes")
else:
print("No")
# print(A[i], A[i-k])
| n, k = list(map(int, input().split()))
A = list(map(int, input().split()))
now = 1000
for i in range(k, n):
# print(A[i], A[i-k])
if A[i] > A[i - k]:
print("Yes")
else:
print("No")
| false | 57.142857 | [
"-import sys, math, itertools, collections, bisect",
"-",
"-input = lambda: sys.stdin.buffer.readline().rstrip().decode(\"utf-8\")",
"-inf = float(\"inf\")",
"-mod = 10**9 + 7",
"-mans = inf",
"-ans = 0",
"-count = 0",
"-pro = 1",
"-import sys, math, itertools, collections, bisect",
"-",
"-input = lambda: sys.stdin.buffer.readline().rstrip().decode(\"utf-8\")",
"-inf = float(\"inf\")",
"-mod = 10**9 + 7",
"-mans = inf",
"-ans = 0",
"-count = 0",
"-pro = 1",
"-for i in range(k - 1, n):",
"- if i == k - 1:",
"- continue",
"+now = 1000",
"+for i in range(k, n):",
"+ # print(A[i], A[i-k])",
"+ if A[i] > A[i - k]:",
"+ print(\"Yes\")",
"- if A[i] > A[i - k]:",
"- print(\"Yes\")",
"- else:",
"- print(\"No\")",
"- # print(A[i], A[i-k])",
"+ print(\"No\")"
] | false | 0.041987 | 0.080515 | 0.521483 | [
"s332117763",
"s230141533"
] |
u530606147 | p02639 | python | s326474411 | s238887977 | 20 | 18 | 9,036 | 9,156 | Accepted | Accepted | 10 | x = list(map(int, input().split()))
print((list(set(range(1, 5 + 1)) - set(x))[0]))
| x = list(map(int, input().split()))
print((sum(range(1, 5 + 1)) - sum(x)))
| 3 | 3 | 85 | 76 | x = list(map(int, input().split()))
print((list(set(range(1, 5 + 1)) - set(x))[0]))
| x = list(map(int, input().split()))
print((sum(range(1, 5 + 1)) - sum(x)))
| false | 0 | [
"-print((list(set(range(1, 5 + 1)) - set(x))[0]))",
"+print((sum(range(1, 5 + 1)) - sum(x)))"
] | false | 0.037994 | 0.040703 | 0.933434 | [
"s326474411",
"s238887977"
] |
u312025627 | p03779 | python | s555021829 | s484701240 | 192 | 173 | 44,656 | 40,560 | Accepted | Accepted | 9.9 | def main():
import sys
input = sys.stdin.buffer.readline
N = int(eval(input()))
from itertools import accumulate
S = [i for i in accumulate(list(range(1, min(N+1, 100000))))]
def is_ok(mid):
if N <= S[mid]:
return True
else:
return False
def binary_search_meguru():
left = -1
right = len(S)
while right - left > 1:
mid = left + ((right - left) // 2)
if is_ok(mid):
right = mid
else:
left = mid
return right
ans = binary_search_meguru() + 1
print(ans)
if __name__ == '__main__':
main()
| def main():
import sys
input = sys.stdin.buffer.readline
N = int(eval(input()))
from itertools import accumulate
S = [i for i in accumulate(list(range(1, min(N+1, 44725))))]
def is_ok(mid):
if N <= S[mid]:
return True
else:
return False
def binary_search_meguru():
left = -1
right = len(S)
while right - left > 1:
mid = left + ((right - left) // 2)
if is_ok(mid):
right = mid
else:
left = mid
return right
ans = binary_search_meguru() + 1
print(ans)
if __name__ == '__main__':
main()
| 30 | 30 | 687 | 686 | def main():
import sys
input = sys.stdin.buffer.readline
N = int(eval(input()))
from itertools import accumulate
S = [i for i in accumulate(list(range(1, min(N + 1, 100000))))]
def is_ok(mid):
if N <= S[mid]:
return True
else:
return False
def binary_search_meguru():
left = -1
right = len(S)
while right - left > 1:
mid = left + ((right - left) // 2)
if is_ok(mid):
right = mid
else:
left = mid
return right
ans = binary_search_meguru() + 1
print(ans)
if __name__ == "__main__":
main()
| def main():
import sys
input = sys.stdin.buffer.readline
N = int(eval(input()))
from itertools import accumulate
S = [i for i in accumulate(list(range(1, min(N + 1, 44725))))]
def is_ok(mid):
if N <= S[mid]:
return True
else:
return False
def binary_search_meguru():
left = -1
right = len(S)
while right - left > 1:
mid = left + ((right - left) // 2)
if is_ok(mid):
right = mid
else:
left = mid
return right
ans = binary_search_meguru() + 1
print(ans)
if __name__ == "__main__":
main()
| false | 0 | [
"- S = [i for i in accumulate(list(range(1, min(N + 1, 100000))))]",
"+ S = [i for i in accumulate(list(range(1, min(N + 1, 44725))))]"
] | false | 0.049903 | 0.046286 | 1.078142 | [
"s555021829",
"s484701240"
] |
u918601425 | p03317 | python | s786781105 | s066389590 | 26 | 17 | 3,060 | 3,060 | Accepted | Accepted | 34.62 | N,K=[int(s) for s in input().split()]
x=1
for i in range(1,N):
x+=(K-1)
if x>=N:
print(i)
break
| N,K=[int(s) for s in input().split()]
print(((N+K-3)//(K-1))) | 9 | 2 | 121 | 60 | N, K = [int(s) for s in input().split()]
x = 1
for i in range(1, N):
x += K - 1
if x >= N:
print(i)
break
| N, K = [int(s) for s in input().split()]
print(((N + K - 3) // (K - 1)))
| false | 77.777778 | [
"-x = 1",
"-for i in range(1, N):",
"- x += K - 1",
"- if x >= N:",
"- print(i)",
"- break",
"+print(((N + K - 3) // (K - 1)))"
] | false | 0.045921 | 0.037234 | 1.233329 | [
"s786781105",
"s066389590"
] |
u740284863 | p03127 | python | s607305448 | s157948747 | 123 | 79 | 14,252 | 14,748 | Accepted | Accepted | 35.77 | import sys
input = sys.stdin.readline
n = int(eval(input()))
A = list(map(int,input().split()))
while True:
if A.count(0) == n - 1:
print((max(A)))
exit()
else:
B = [ _ for _ in A if _ != 0 ]
attack = min(B)
sn = A.index(attack)
for i in range(n):
if A[i] == 0:
pass
else:
if i != sn:
A[i] = A[i] % attack
else:
pass
| import sys
input = sys.stdin.readline
from functools import reduce
def gcd_list(n):
return reduce(gcd, n)
def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
n = int(eval(input()))
a = list(map(int, input().split()))
print((gcd_list(a)))
| 21 | 14 | 508 | 269 | import sys
input = sys.stdin.readline
n = int(eval(input()))
A = list(map(int, input().split()))
while True:
if A.count(0) == n - 1:
print((max(A)))
exit()
else:
B = [_ for _ in A if _ != 0]
attack = min(B)
sn = A.index(attack)
for i in range(n):
if A[i] == 0:
pass
else:
if i != sn:
A[i] = A[i] % attack
else:
pass
| import sys
input = sys.stdin.readline
from functools import reduce
def gcd_list(n):
return reduce(gcd, n)
def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
n = int(eval(input()))
a = list(map(int, input().split()))
print((gcd_list(a)))
| false | 33.333333 | [
"+from functools import reduce",
"+",
"+",
"+def gcd_list(n):",
"+ return reduce(gcd, n)",
"+",
"+",
"+def gcd(a, b):",
"+ if b == 0:",
"+ return a",
"+ return gcd(b, a % b)",
"+",
"+",
"-A = list(map(int, input().split()))",
"-while True:",
"- if A.count(0) == n - 1:",
"- print((max(A)))",
"- exit()",
"- else:",
"- B = [_ for _ in A if _ != 0]",
"- attack = min(B)",
"- sn = A.index(attack)",
"- for i in range(n):",
"- if A[i] == 0:",
"- pass",
"- else:",
"- if i != sn:",
"- A[i] = A[i] % attack",
"- else:",
"- pass",
"+a = list(map(int, input().split()))",
"+print((gcd_list(a)))"
] | false | 0.060572 | 0.101461 | 0.597 | [
"s607305448",
"s157948747"
] |
u803848678 | p02852 | python | s361608794 | s787202913 | 454 | 322 | 65,128 | 54,748 | Accepted | Accepted | 29.07 | import sys
input = sys.stdin.readline
# 区間更新
# 小さいものを残すパターン
class RangeUpdateQuery:
def __init__(self, n):
self.n0 = 2**(n-1).bit_length()
# 初期値
self.INF = float("inf")
self.data = [self.INF]*(2*self.n0-1)
# 0-indexedで[l, r)をvに更新
# [l, r]を更新したかったら (l, r+1)を引数に入れる
# minが更新される場合だけ残す
def update(self, l,r,v):
l += self.n0
r += self.n0
while l < r:
if r&1:
r -= 1
if self.data[r-1] > v:
self.data[r-1] = v
if l&1:
if self.data[l-1] > v:
self.data[l-1] = v
l += 1
l >>=1
r >>=1
def query(self, i):
i += self.n0-1
res = self.INF
while i+1:
if self.data[i] < res:
res = self.data[i]
i = ~-i//2
return res
n,m = list(map(int, input().split()))
s = input()[:-1]
DP = [-1]*(n+1)
seg = RangeUpdateQuery(n+1)
seg.update(0,1,0)
ss = s[::-1]
for i in range(n):
if ss[i] == "1":
continue
cnt = seg.query(i)
if cnt == float("inf"):
continue
seg.update(i+1, min(i+m+1, n+1), cnt+1)
if seg.query(n) == float("inf"):
print((-1))
exit()
a = [seg.query(i) for i in reversed(list(range(n+1)))]
for i in range(n+1):
if s[i] == "1":
a[i] = float("inf")
prev = a[0]
j = 0
ans = []
for i in range(n+1):
if a[i]<prev:
prev = a[i]
ans.append(i-j)
j = i
print((*ans)) | from heapq import heappop, heappush
n,m = list(map(int, input().split()))
s = eval(input())
heap = [(0,n)]
turn = [-1]*(n+1)
turn[-1] = 0
for i in range(n-1, -1, -1):
if s[i] == "1":
continue
while heap and heap[0][1]-i>m:
heappop(heap)
if not heap:
break
cnt, prev = heap[0]
turn[i] = cnt+1
heappush(heap, (turn[i], i))
if turn[0] == -1:
print((-1))
exit()
prev_turn=turn[0]
prev_ind = 0
ans = []
for i in range(1, n+1):
if prev_turn-turn[i] == 1:
ans.append(i-prev_ind)
prev_ind = i
prev_turn = turn[i]
print((*ans)) | 71 | 31 | 1,584 | 619 | import sys
input = sys.stdin.readline
# 区間更新
# 小さいものを残すパターン
class RangeUpdateQuery:
def __init__(self, n):
self.n0 = 2 ** (n - 1).bit_length()
# 初期値
self.INF = float("inf")
self.data = [self.INF] * (2 * self.n0 - 1)
# 0-indexedで[l, r)をvに更新
# [l, r]を更新したかったら (l, r+1)を引数に入れる
# minが更新される場合だけ残す
def update(self, l, r, v):
l += self.n0
r += self.n0
while l < r:
if r & 1:
r -= 1
if self.data[r - 1] > v:
self.data[r - 1] = v
if l & 1:
if self.data[l - 1] > v:
self.data[l - 1] = v
l += 1
l >>= 1
r >>= 1
def query(self, i):
i += self.n0 - 1
res = self.INF
while i + 1:
if self.data[i] < res:
res = self.data[i]
i = ~-i // 2
return res
n, m = list(map(int, input().split()))
s = input()[:-1]
DP = [-1] * (n + 1)
seg = RangeUpdateQuery(n + 1)
seg.update(0, 1, 0)
ss = s[::-1]
for i in range(n):
if ss[i] == "1":
continue
cnt = seg.query(i)
if cnt == float("inf"):
continue
seg.update(i + 1, min(i + m + 1, n + 1), cnt + 1)
if seg.query(n) == float("inf"):
print((-1))
exit()
a = [seg.query(i) for i in reversed(list(range(n + 1)))]
for i in range(n + 1):
if s[i] == "1":
a[i] = float("inf")
prev = a[0]
j = 0
ans = []
for i in range(n + 1):
if a[i] < prev:
prev = a[i]
ans.append(i - j)
j = i
print((*ans))
| from heapq import heappop, heappush
n, m = list(map(int, input().split()))
s = eval(input())
heap = [(0, n)]
turn = [-1] * (n + 1)
turn[-1] = 0
for i in range(n - 1, -1, -1):
if s[i] == "1":
continue
while heap and heap[0][1] - i > m:
heappop(heap)
if not heap:
break
cnt, prev = heap[0]
turn[i] = cnt + 1
heappush(heap, (turn[i], i))
if turn[0] == -1:
print((-1))
exit()
prev_turn = turn[0]
prev_ind = 0
ans = []
for i in range(1, n + 1):
if prev_turn - turn[i] == 1:
ans.append(i - prev_ind)
prev_ind = i
prev_turn = turn[i]
print((*ans))
| false | 56.338028 | [
"-import sys",
"-",
"-input = sys.stdin.readline",
"-# 区間更新",
"-# 小さいものを残すパターン",
"-class RangeUpdateQuery:",
"- def __init__(self, n):",
"- self.n0 = 2 ** (n - 1).bit_length()",
"- # 初期値",
"- self.INF = float(\"inf\")",
"- self.data = [self.INF] * (2 * self.n0 - 1)",
"-",
"- # 0-indexedで[l, r)をvに更新",
"- # [l, r]を更新したかったら (l, r+1)を引数に入れる",
"- # minが更新される場合だけ残す",
"- def update(self, l, r, v):",
"- l += self.n0",
"- r += self.n0",
"- while l < r:",
"- if r & 1:",
"- r -= 1",
"- if self.data[r - 1] > v:",
"- self.data[r - 1] = v",
"- if l & 1:",
"- if self.data[l - 1] > v:",
"- self.data[l - 1] = v",
"- l += 1",
"- l >>= 1",
"- r >>= 1",
"-",
"- def query(self, i):",
"- i += self.n0 - 1",
"- res = self.INF",
"- while i + 1:",
"- if self.data[i] < res:",
"- res = self.data[i]",
"- i = ~-i // 2",
"- return res",
"-",
"+from heapq import heappop, heappush",
"-s = input()[:-1]",
"-DP = [-1] * (n + 1)",
"-seg = RangeUpdateQuery(n + 1)",
"-seg.update(0, 1, 0)",
"-ss = s[::-1]",
"-for i in range(n):",
"- if ss[i] == \"1\":",
"+s = eval(input())",
"+heap = [(0, n)]",
"+turn = [-1] * (n + 1)",
"+turn[-1] = 0",
"+for i in range(n - 1, -1, -1):",
"+ if s[i] == \"1\":",
"- cnt = seg.query(i)",
"- if cnt == float(\"inf\"):",
"- continue",
"- seg.update(i + 1, min(i + m + 1, n + 1), cnt + 1)",
"-if seg.query(n) == float(\"inf\"):",
"+ while heap and heap[0][1] - i > m:",
"+ heappop(heap)",
"+ if not heap:",
"+ break",
"+ cnt, prev = heap[0]",
"+ turn[i] = cnt + 1",
"+ heappush(heap, (turn[i], i))",
"+if turn[0] == -1:",
"-a = [seg.query(i) for i in reversed(list(range(n + 1)))]",
"-for i in range(n + 1):",
"- if s[i] == \"1\":",
"- a[i] = float(\"inf\")",
"-prev = a[0]",
"-j = 0",
"+prev_turn = turn[0]",
"+prev_ind = 0",
"-for i in range(n + 1):",
"- if a[i] < prev:",
"- prev = a[i]",
"- ans.append(i - j)",
"- j = i",
"+for i in range(1, n + 1):",
"+ if prev_turn - turn[i] == 1:",
"+ ans.append(i - prev_ind)",
"+ prev_ind = i",
"+ prev_turn = turn[i]"
] | false | 0.080049 | 0.044923 | 1.781896 | [
"s361608794",
"s787202913"
] |
u263830634 | p03038 | python | s978422761 | s151329582 | 715 | 338 | 34,952 | 31,964 | Accepted | Accepted | 52.73 | N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
cb = []
for i in A:
cb += [[i,1]]
for _ in range(M):
b, c = list(map(int, input().split()))
cb += [[c, b]]
cb.sort(reverse = True)
#print (cb)
ans = 0
i = 0
j = 0
while i <= N:
a = min(N-i, cb[j][1])
ans += cb[j][0] * a
j += 1
i += a
#print (ans)
if i == N:
print (ans)
i += 1
| import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
BC = [tuple(map(int, input().split())) for _ in range(M)]
BC_append = BC.append
for a in A:
BC_append((1, a))
BC.sort(key = lambda x: x[1])
ans = 0
while N > 0:
bc = BC.pop()
b = bc[0]
c = bc[1]
if b > N:
ans += c * N
N = 0
else:
ans += c * b
N -= b
print (ans)
| 24 | 27 | 417 | 461 | N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
cb = []
for i in A:
cb += [[i, 1]]
for _ in range(M):
b, c = list(map(int, input().split()))
cb += [[c, b]]
cb.sort(reverse=True)
# print (cb)
ans = 0
i = 0
j = 0
while i <= N:
a = min(N - i, cb[j][1])
ans += cb[j][0] * a
j += 1
i += a
# print (ans)
if i == N:
print(ans)
i += 1
| import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
BC = [tuple(map(int, input().split())) for _ in range(M)]
BC_append = BC.append
for a in A:
BC_append((1, a))
BC.sort(key=lambda x: x[1])
ans = 0
while N > 0:
bc = BC.pop()
b = bc[0]
c = bc[1]
if b > N:
ans += c * N
N = 0
else:
ans += c * b
N -= b
print(ans)
| false | 11.111111 | [
"+import sys",
"+",
"+input = sys.stdin.readline",
"-cb = []",
"-for i in A:",
"- cb += [[i, 1]]",
"-for _ in range(M):",
"- b, c = list(map(int, input().split()))",
"- cb += [[c, b]]",
"-cb.sort(reverse=True)",
"-# print (cb)",
"+BC = [tuple(map(int, input().split())) for _ in range(M)]",
"+BC_append = BC.append",
"+for a in A:",
"+ BC_append((1, a))",
"+BC.sort(key=lambda x: x[1])",
"-i = 0",
"-j = 0",
"-while i <= N:",
"- a = min(N - i, cb[j][1])",
"- ans += cb[j][0] * a",
"- j += 1",
"- i += a",
"- # print (ans)",
"- if i == N:",
"- print(ans)",
"- i += 1",
"+while N > 0:",
"+ bc = BC.pop()",
"+ b = bc[0]",
"+ c = bc[1]",
"+ if b > N:",
"+ ans += c * N",
"+ N = 0",
"+ else:",
"+ ans += c * b",
"+ N -= b",
"+print(ans)"
] | false | 0.038882 | 0.045998 | 0.845307 | [
"s978422761",
"s151329582"
] |
u102461423 | p03885 | python | s943997360 | s564479197 | 1,119 | 228 | 227,888 | 16,900 | Accepted | Accepted | 79.62 | from numpy import *
P=10**9+7
N=int(eval(input()))
C=array([input().split() for _ in range(N)],int8)
def r(A):
if(A==0).all():return 0
i=A[:,0].nonzero()[0]
if len(i) == 0:return r(A[:,1:])
t=A[i[0]].copy();A[i[0]]=A[0];A[0]=t
A[1:]^= A[1:,0][:,None]*A[0][None,:]
return 1+r(A[1:,1:])
r=r(C)
p=ones(N+1,int64)
for n in range(1,N+1):p[n]=p[n-1]*2%P
d=zeros((N+1,N+1,N+1),int64);d[:,0,0]=1
for M in range(1,N+1):
d[:,M,:M]+=d[:,M-1,:M]*p[:M]%P
d[:,M,1:M+1]+=d[:,M-1,0:M]*(p[:,None]-p[None,0:M])%P
d[:,M,:]%=P
print((sum(d[N,N,n]*d[N,n,r]%P*pow(2,N*(N-n),P)%P for n in range(r,N+1))%P*pow(int(d[N,N,r]),P-2,P)%P)) | import sys
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 7)
import numpy as np
MOD = 10**9 + 7
N = int(readline())
C = np.array([line.split() for line in readlines()],np.int8)
def rank(A):
if (A==0).all():
return 0
i = np.nonzero(A[:,0])[0]
if len(i) == 0:
return rank(A[:,1:])
i = i[0]
temp = A[i].copy()
A[i] = A[0]
A[0] = temp
A[1:] ^= A[1:,0][:,None] * A[0][None,:]
return 1 + rank(A[1:,1:])
def cumprod(arr,MOD):
L = len(arr); Lsq = int(L**.5+1)
arr = np.resize(arr,Lsq**2).reshape(Lsq,Lsq)
for n in range(1,Lsq):
arr[:,n] *= arr[:,n-1]; arr[:,n] %= MOD
for n in range(1,Lsq):
arr[n] *= arr[n-1,-1]; arr[n] %= MOD
return arr.ravel()[:L]
def power_mod(a,n,MOD):
if n == 0:
return 1
x = power_mod(a,n//2,MOD)
x *= x
x %= MOD
return (a*x)%MOD if n&1 else x
r = rank(C)
x = np.full(N*N+100,2,np.int64); x[0] = 1
pow2 = cumprod(x,MOD)
G = np.zeros((N+1,N+1),np.int64)
for n in range(N+1):
G[n,1:] = pow2[n] - pow2[:N]
G[:,0] = 1
for n in range(1,N+1):
G[:,n] *= G[:,n-1]; G[:,n] %= MOD
Gd = np.diagonal(G)
D = G * power_mod(Gd,MOD-2,MOD)[None,:] % MOD
F = np.zeros((N+1,N+1),np.int64)
for n in range(N+1):
F[n,:n+1] = Gd[:n+1] * D[n,n::-1] % MOD
B = D[N] * F[N] % MOD
C = D[N,r] * F[:,r] % MOD * pow2[N*N::-N] % MOD
A = (B[r:N+1] * C[r:N+1] % MOD).sum() % MOD
answer = A * pow(int(B[r]),MOD-2,MOD) % MOD
print(answer) | 20 | 69 | 639 | 1,572 | from numpy import *
P = 10**9 + 7
N = int(eval(input()))
C = array([input().split() for _ in range(N)], int8)
def r(A):
if (A == 0).all():
return 0
i = A[:, 0].nonzero()[0]
if len(i) == 0:
return r(A[:, 1:])
t = A[i[0]].copy()
A[i[0]] = A[0]
A[0] = t
A[1:] ^= A[1:, 0][:, None] * A[0][None, :]
return 1 + r(A[1:, 1:])
r = r(C)
p = ones(N + 1, int64)
for n in range(1, N + 1):
p[n] = p[n - 1] * 2 % P
d = zeros((N + 1, N + 1, N + 1), int64)
d[:, 0, 0] = 1
for M in range(1, N + 1):
d[:, M, :M] += d[:, M - 1, :M] * p[:M] % P
d[:, M, 1 : M + 1] += d[:, M - 1, 0:M] * (p[:, None] - p[None, 0:M]) % P
d[:, M, :] %= P
print(
(
sum(
d[N, N, n] * d[N, n, r] % P * pow(2, N * (N - n), P) % P
for n in range(r, N + 1)
)
% P
* pow(int(d[N, N, r]), P - 2, P)
% P
)
)
| import sys
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10**7)
import numpy as np
MOD = 10**9 + 7
N = int(readline())
C = np.array([line.split() for line in readlines()], np.int8)
def rank(A):
if (A == 0).all():
return 0
i = np.nonzero(A[:, 0])[0]
if len(i) == 0:
return rank(A[:, 1:])
i = i[0]
temp = A[i].copy()
A[i] = A[0]
A[0] = temp
A[1:] ^= A[1:, 0][:, None] * A[0][None, :]
return 1 + rank(A[1:, 1:])
def cumprod(arr, MOD):
L = len(arr)
Lsq = int(L**0.5 + 1)
arr = np.resize(arr, Lsq**2).reshape(Lsq, Lsq)
for n in range(1, Lsq):
arr[:, n] *= arr[:, n - 1]
arr[:, n] %= MOD
for n in range(1, Lsq):
arr[n] *= arr[n - 1, -1]
arr[n] %= MOD
return arr.ravel()[:L]
def power_mod(a, n, MOD):
if n == 0:
return 1
x = power_mod(a, n // 2, MOD)
x *= x
x %= MOD
return (a * x) % MOD if n & 1 else x
r = rank(C)
x = np.full(N * N + 100, 2, np.int64)
x[0] = 1
pow2 = cumprod(x, MOD)
G = np.zeros((N + 1, N + 1), np.int64)
for n in range(N + 1):
G[n, 1:] = pow2[n] - pow2[:N]
G[:, 0] = 1
for n in range(1, N + 1):
G[:, n] *= G[:, n - 1]
G[:, n] %= MOD
Gd = np.diagonal(G)
D = G * power_mod(Gd, MOD - 2, MOD)[None, :] % MOD
F = np.zeros((N + 1, N + 1), np.int64)
for n in range(N + 1):
F[n, : n + 1] = Gd[: n + 1] * D[n, n::-1] % MOD
B = D[N] * F[N] % MOD
C = D[N, r] * F[:, r] % MOD * pow2[N * N :: -N] % MOD
A = (B[r : N + 1] * C[r : N + 1] % MOD).sum() % MOD
answer = A * pow(int(B[r]), MOD - 2, MOD) % MOD
print(answer)
| false | 71.014493 | [
"-from numpy import *",
"+import sys",
"-P = 10**9 + 7",
"-N = int(eval(input()))",
"-C = array([input().split() for _ in range(N)], int8)",
"+readline = sys.stdin.readline",
"+readlines = sys.stdin.readlines",
"+sys.setrecursionlimit(10**7)",
"+import numpy as np",
"+",
"+MOD = 10**9 + 7",
"+N = int(readline())",
"+C = np.array([line.split() for line in readlines()], np.int8)",
"-def r(A):",
"+def rank(A):",
"- i = A[:, 0].nonzero()[0]",
"+ i = np.nonzero(A[:, 0])[0]",
"- return r(A[:, 1:])",
"- t = A[i[0]].copy()",
"- A[i[0]] = A[0]",
"- A[0] = t",
"+ return rank(A[:, 1:])",
"+ i = i[0]",
"+ temp = A[i].copy()",
"+ A[i] = A[0]",
"+ A[0] = temp",
"- return 1 + r(A[1:, 1:])",
"+ return 1 + rank(A[1:, 1:])",
"-r = r(C)",
"-p = ones(N + 1, int64)",
"+def cumprod(arr, MOD):",
"+ L = len(arr)",
"+ Lsq = int(L**0.5 + 1)",
"+ arr = np.resize(arr, Lsq**2).reshape(Lsq, Lsq)",
"+ for n in range(1, Lsq):",
"+ arr[:, n] *= arr[:, n - 1]",
"+ arr[:, n] %= MOD",
"+ for n in range(1, Lsq):",
"+ arr[n] *= arr[n - 1, -1]",
"+ arr[n] %= MOD",
"+ return arr.ravel()[:L]",
"+",
"+",
"+def power_mod(a, n, MOD):",
"+ if n == 0:",
"+ return 1",
"+ x = power_mod(a, n // 2, MOD)",
"+ x *= x",
"+ x %= MOD",
"+ return (a * x) % MOD if n & 1 else x",
"+",
"+",
"+r = rank(C)",
"+x = np.full(N * N + 100, 2, np.int64)",
"+x[0] = 1",
"+pow2 = cumprod(x, MOD)",
"+G = np.zeros((N + 1, N + 1), np.int64)",
"+for n in range(N + 1):",
"+ G[n, 1:] = pow2[n] - pow2[:N]",
"+G[:, 0] = 1",
"- p[n] = p[n - 1] * 2 % P",
"-d = zeros((N + 1, N + 1, N + 1), int64)",
"-d[:, 0, 0] = 1",
"-for M in range(1, N + 1):",
"- d[:, M, :M] += d[:, M - 1, :M] * p[:M] % P",
"- d[:, M, 1 : M + 1] += d[:, M - 1, 0:M] * (p[:, None] - p[None, 0:M]) % P",
"- d[:, M, :] %= P",
"-print(",
"- (",
"- sum(",
"- d[N, N, n] * d[N, n, r] % P * pow(2, N * (N - n), P) % P",
"- for n in range(r, N + 1)",
"- )",
"- % P",
"- * pow(int(d[N, N, r]), P - 2, P)",
"- % P",
"- )",
"-)",
"+ G[:, n] *= G[:, n - 1]",
"+ G[:, n] %= MOD",
"+Gd = np.diagonal(G)",
"+D = G * power_mod(Gd, MOD - 2, MOD)[None, :] % MOD",
"+F = np.zeros((N + 1, N + 1), np.int64)",
"+for n in range(N + 1):",
"+ F[n, : n + 1] = Gd[: n + 1] * D[n, n::-1] % MOD",
"+B = D[N] * F[N] % MOD",
"+C = D[N, r] * F[:, r] % MOD * pow2[N * N :: -N] % MOD",
"+A = (B[r : N + 1] * C[r : N + 1] % MOD).sum() % MOD",
"+answer = A * pow(int(B[r]), MOD - 2, MOD) % MOD",
"+print(answer)"
] | false | 0.182533 | 0.2995 | 0.609459 | [
"s943997360",
"s564479197"
] |
u411203878 | p03696 | python | s752738279 | s027815201 | 164 | 69 | 38,256 | 61,952 | Accepted | Accepted | 57.93 | n=int(eval(input()))
s=eval(input())
s=list(s)
flag = True
ans = []
count = 0
for i in s:
if flag:
if i==')':
ans.append(')')
ans.insert(0, '(')
else:
flag = False
ans.append('(')
count += 1
else:
if i=='(':
count += 1
ans.append('(')
else:
ans.append(')')
count -= 1
if count == 0:
flag = True
for j in range(count):
ans.append(')')
print((''.join(map(str,ans)))) | N = int(eval(input()))
S = list(eval(input()))
ans = []
count = 0
addFlag = True
for i in range(N):
if addFlag:
if S[i] == ')':
ans.append(')')
ans.insert(0,'(')
else:
ans.append('(')
count += 1
addFlag = False
else:
if S[i] == '(':
ans.append('(')
count += 1
else:
ans.append(')')
count -= 1
if count == 0:
addFlag = True
for _ in range(count):
ans.append(')')
print((''.join(ans))) | 33 | 29 | 584 | 580 | n = int(eval(input()))
s = eval(input())
s = list(s)
flag = True
ans = []
count = 0
for i in s:
if flag:
if i == ")":
ans.append(")")
ans.insert(0, "(")
else:
flag = False
ans.append("(")
count += 1
else:
if i == "(":
count += 1
ans.append("(")
else:
ans.append(")")
count -= 1
if count == 0:
flag = True
for j in range(count):
ans.append(")")
print(("".join(map(str, ans))))
| N = int(eval(input()))
S = list(eval(input()))
ans = []
count = 0
addFlag = True
for i in range(N):
if addFlag:
if S[i] == ")":
ans.append(")")
ans.insert(0, "(")
else:
ans.append("(")
count += 1
addFlag = False
else:
if S[i] == "(":
ans.append("(")
count += 1
else:
ans.append(")")
count -= 1
if count == 0:
addFlag = True
for _ in range(count):
ans.append(")")
print(("".join(ans)))
| false | 12.121212 | [
"-n = int(eval(input()))",
"-s = eval(input())",
"-s = list(s)",
"-flag = True",
"+N = int(eval(input()))",
"+S = list(eval(input()))",
"-for i in s:",
"- if flag:",
"- if i == \")\":",
"+addFlag = True",
"+for i in range(N):",
"+ if addFlag:",
"+ if S[i] == \")\":",
"- flag = False",
"+ addFlag = False",
"- if i == \"(\":",
"+ if S[i] == \"(\":",
"+ ans.append(\"(\")",
"- ans.append(\"(\")",
"- flag = True",
"-for j in range(count):",
"+ addFlag = True",
"+for _ in range(count):",
"-print((\"\".join(map(str, ans))))",
"+print((\"\".join(ans)))"
] | false | 0.035234 | 0.035817 | 0.983724 | [
"s752738279",
"s027815201"
] |
u873190923 | p02948 | python | s958463597 | s101900381 | 989 | 885 | 74,200 | 78,168 | Accepted | Accepted | 10.52 | import heapq # 優先度付きキュー(最小値取り出し)
n,m = list(map(int, input().split()))
a = [list(map(int,input().split())) for i in range(n)]
a.sort(reverse = True)
b = []
heapq.heapify(b) # ヒープ化
ans = 0
for i in range(1,m+1):
while a and a[-1][0] == i:
val = a.pop()[1]
heapq.heappush(b, (-1)*(val)) # 今考えてる日にちの価値をpush
if b:
val = heapq.heappop(b)*(-1) # 最大値の取り出し
ans += val
print(ans) | import heapq # 優先度付きキュー(最小値取り出し)
inf = 10**15
mod = 10**9+7
n,m = list(map(int, input().split()))
ab = [list(map(int, input().split())) for i in range(n)]
ab.sort(key = lambda x:x[0], reverse = True)
q = []
heapq.heapify(q) # ヒープ化
ans = 0
for i in range(1,m+1): # m-i日目からスタートして間に合う仕事
while ab and ab[-1][0] == i:
_,val = ab.pop()
heapq.heappush(q, (-1) * val)
if q:
ans += heapq.heappop(q) * (-1)
print(ans) | 16 | 18 | 444 | 454 | import heapq # 優先度付きキュー(最小値取り出し)
n, m = list(map(int, input().split()))
a = [list(map(int, input().split())) for i in range(n)]
a.sort(reverse=True)
b = []
heapq.heapify(b) # ヒープ化
ans = 0
for i in range(1, m + 1):
while a and a[-1][0] == i:
val = a.pop()[1]
heapq.heappush(b, (-1) * (val)) # 今考えてる日にちの価値をpush
if b:
val = heapq.heappop(b) * (-1) # 最大値の取り出し
ans += val
print(ans)
| import heapq # 優先度付きキュー(最小値取り出し)
inf = 10**15
mod = 10**9 + 7
n, m = list(map(int, input().split()))
ab = [list(map(int, input().split())) for i in range(n)]
ab.sort(key=lambda x: x[0], reverse=True)
q = []
heapq.heapify(q) # ヒープ化
ans = 0
for i in range(1, m + 1): # m-i日目からスタートして間に合う仕事
while ab and ab[-1][0] == i:
_, val = ab.pop()
heapq.heappush(q, (-1) * val)
if q:
ans += heapq.heappop(q) * (-1)
print(ans)
| false | 11.111111 | [
"+inf = 10**15",
"+mod = 10**9 + 7",
"-a = [list(map(int, input().split())) for i in range(n)]",
"-a.sort(reverse=True)",
"-b = []",
"-heapq.heapify(b) # ヒープ化",
"+ab = [list(map(int, input().split())) for i in range(n)]",
"+ab.sort(key=lambda x: x[0], reverse=True)",
"+q = []",
"+heapq.heapify(q) # ヒープ化",
"-for i in range(1, m + 1):",
"- while a and a[-1][0] == i:",
"- val = a.pop()[1]",
"- heapq.heappush(b, (-1) * (val)) # 今考えてる日にちの価値をpush",
"- if b:",
"- val = heapq.heappop(b) * (-1) # 最大値の取り出し",
"- ans += val",
"+for i in range(1, m + 1): # m-i日目からスタートして間に合う仕事",
"+ while ab and ab[-1][0] == i:",
"+ _, val = ab.pop()",
"+ heapq.heappush(q, (-1) * val)",
"+ if q:",
"+ ans += heapq.heappop(q) * (-1)"
] | false | 0.07685 | 0.073231 | 1.049415 | [
"s958463597",
"s101900381"
] |
u716530146 | p03997 | python | s043667256 | s178036381 | 281 | 168 | 64,364 | 38,256 | Accepted | Accepted | 40.21 | #!/usr/bin/env python3
import sys, math, itertools, heapq, collections, bisect, fractions
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
sys.setrecursionlimit(10**8)
inf = float('inf')
ans = count = 0
a,b,h=[int(eval(input())) for i in range(3)]
print(((a+b)*h//2)) | #!/usr/bin/env python3
import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1
a=int(eval(input()))
b=int(eval(input()))
h=int(eval(input()))
print(((a+b)*h//2)) | 9 | 10 | 288 | 287 | #!/usr/bin/env python3
import sys, math, itertools, heapq, collections, bisect, fractions
input = lambda: sys.stdin.buffer.readline().rstrip().decode("utf-8")
sys.setrecursionlimit(10**8)
inf = float("inf")
ans = count = 0
a, b, h = [int(eval(input())) for i in range(3)]
print(((a + b) * h // 2))
| #!/usr/bin/env python3
import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode("utf-8")
inf = float("inf")
mod = 10**9 + 7
mans = inf
ans = 0
count = 0
pro = 1
a = int(eval(input()))
b = int(eval(input()))
h = int(eval(input()))
print(((a + b) * h // 2))
| false | 10 | [
"-import sys, math, itertools, heapq, collections, bisect, fractions",
"+import sys, math, itertools, collections, bisect",
"-sys.setrecursionlimit(10**8)",
"-ans = count = 0",
"-a, b, h = [int(eval(input())) for i in range(3)]",
"+mod = 10**9 + 7",
"+mans = inf",
"+ans = 0",
"+count = 0",
"+pro = 1",
"+a = int(eval(input()))",
"+b = int(eval(input()))",
"+h = int(eval(input()))"
] | false | 0.040309 | 0.035749 | 1.127554 | [
"s043667256",
"s178036381"
] |
u623231048 | p03645 | python | s013581890 | s443268620 | 697 | 584 | 11,420 | 6,132 | Accepted | Accepted | 16.21 | n,m = list(map(int,input().split()))
li1 = []
lin = []
for _ in range(m):
a,b = list(map(int,input().split()))
if a == 1:
li1.append(b)
elif b == n:
lin.append(a)
li1.sort()
lin.sort()
tmp = 0
if not len(lin):
print('IMPOSSIBLE')
exit()
for i in li1:
while i > lin[tmp]:
tmp += 1
if tmp == len(lin):
print('IMPOSSIBLE')
exit()
if i == lin[tmp]:
print('POSSIBLE')
exit()
print('IMPOSSIBLE')
| n,m = list(map(int,input().split()))
li1 = [False] * n
lin = [False] * n
for _ in range(m):
a,b = list(map(int,input().split()))
if a == 1:
li1[b-1] = True
elif b == n:
lin[a-1] = True
for i in range(n):
if li1[i] and lin[i]:
print('POSSIBLE')
exit()
print('IMPOSSIBLE')
| 33 | 18 | 518 | 328 | n, m = list(map(int, input().split()))
li1 = []
lin = []
for _ in range(m):
a, b = list(map(int, input().split()))
if a == 1:
li1.append(b)
elif b == n:
lin.append(a)
li1.sort()
lin.sort()
tmp = 0
if not len(lin):
print("IMPOSSIBLE")
exit()
for i in li1:
while i > lin[tmp]:
tmp += 1
if tmp == len(lin):
print("IMPOSSIBLE")
exit()
if i == lin[tmp]:
print("POSSIBLE")
exit()
print("IMPOSSIBLE")
| n, m = list(map(int, input().split()))
li1 = [False] * n
lin = [False] * n
for _ in range(m):
a, b = list(map(int, input().split()))
if a == 1:
li1[b - 1] = True
elif b == n:
lin[a - 1] = True
for i in range(n):
if li1[i] and lin[i]:
print("POSSIBLE")
exit()
print("IMPOSSIBLE")
| false | 45.454545 | [
"-li1 = []",
"-lin = []",
"+li1 = [False] * n",
"+lin = [False] * n",
"- li1.append(b)",
"+ li1[b - 1] = True",
"- lin.append(a)",
"-li1.sort()",
"-lin.sort()",
"-tmp = 0",
"-if not len(lin):",
"- print(\"IMPOSSIBLE\")",
"- exit()",
"-for i in li1:",
"- while i > lin[tmp]:",
"- tmp += 1",
"- if tmp == len(lin):",
"- print(\"IMPOSSIBLE\")",
"- exit()",
"- if i == lin[tmp]:",
"+ lin[a - 1] = True",
"+for i in range(n):",
"+ if li1[i] and lin[i]:"
] | false | 0.047792 | 0.049436 | 0.966751 | [
"s013581890",
"s443268620"
] |
u416011173 | p03294 | python | s143403131 | s787211486 | 43 | 26 | 10,660 | 9,248 | Accepted | Accepted | 39.53 | # モジュールのインポート
import fractions
# 標準入力を取得
N = int(eval(input()))
a = list(map(int, input().split()))
# 求解処理
ans = sum(a) - N
# 結果出力
print(ans)
| # -*- coding: utf-8 -*-
def get_input() -> tuple:
"""
標準入力を取得する.
Returns:\n
tuple: 標準入力
"""
N = int(eval(input()))
a = list(map(int, input().split()))
return N, a
def main(N: int, a: list) -> None:
"""
メイン処理.
Args:\n
N (int): 正整数の数(2 <= N <= 3000)
a (list): 正整数(2 <= a_i <= 10^5)
"""
# 求解処理
ans = sum(a) - N
# 結果出力
print(ans)
if __name__ == "__main__":
# 標準入力を取得
N, a = get_input()
# メイン処理
main(N, a)
| 12 | 36 | 150 | 540 | # モジュールのインポート
import fractions
# 標準入力を取得
N = int(eval(input()))
a = list(map(int, input().split()))
# 求解処理
ans = sum(a) - N
# 結果出力
print(ans)
| # -*- coding: utf-8 -*-
def get_input() -> tuple:
"""
標準入力を取得する.
Returns:\n
tuple: 標準入力
"""
N = int(eval(input()))
a = list(map(int, input().split()))
return N, a
def main(N: int, a: list) -> None:
"""
メイン処理.
Args:\n
N (int): 正整数の数(2 <= N <= 3000)
a (list): 正整数(2 <= a_i <= 10^5)
"""
# 求解処理
ans = sum(a) - N
# 結果出力
print(ans)
if __name__ == "__main__":
# 標準入力を取得
N, a = get_input()
# メイン処理
main(N, a)
| false | 66.666667 | [
"-# モジュールのインポート",
"-import fractions",
"+# -*- coding: utf-8 -*-",
"+def get_input() -> tuple:",
"+ \"\"\"",
"+ 標準入力を取得する.",
"+ Returns:\\n",
"+ tuple: 標準入力",
"+ \"\"\"",
"+ N = int(eval(input()))",
"+ a = list(map(int, input().split()))",
"+ return N, a",
"-# 標準入力を取得",
"-N = int(eval(input()))",
"-a = list(map(int, input().split()))",
"-# 求解処理",
"-ans = sum(a) - N",
"-# 結果出力",
"-print(ans)",
"+",
"+def main(N: int, a: list) -> None:",
"+ \"\"\"",
"+ メイン処理.",
"+ Args:\\n",
"+ N (int): 正整数の数(2 <= N <= 3000)",
"+ a (list): 正整数(2 <= a_i <= 10^5)",
"+ \"\"\"",
"+ # 求解処理",
"+ ans = sum(a) - N",
"+ # 結果出力",
"+ print(ans)",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ # 標準入力を取得",
"+ N, a = get_input()",
"+ # メイン処理",
"+ main(N, a)"
] | false | 0.085585 | 0.099965 | 0.856149 | [
"s143403131",
"s787211486"
] |
u408260374 | p02364 | python | s864133185 | s386144746 | 1,450 | 1,210 | 47,768 | 45,224 | Accepted | Accepted | 16.55 | from heapq import heappush, heappop
class Prim:
""" find minimum spanning tree by Prim's algorithm
"""
def __init__(self, V, E, start=0, INF=10**9):
""" V: the number of vertexes
E: adjacency list (undirected graph)
start: start vertex
INF: Infinity cost
"""
self.prim(V, E, start, INF)
def prim(self, V, E, start=0, INF=10**9):
used = [False] * V
self.mincost = 0
que = []
heappush(que, (0, 0))
while len(que) > 0:
cost, v = heappop(que)
if used[v]: continue
used[v] = True
self.mincost += cost
for to, c in E[v]:
heappush(que, (c, to))
def minCost(self):
return self.mincost
V, E = list(map(int, input().split()))
edge = [[] for _ in range(V)]
for _ in range(E):
s, t, w = list(map(int, input().split()))
edge[s].append((t, w))
edge[t].append((s, w))
msp = Prim(V, edge)
print((msp.minCost())) | class UnionFindTree:
"""Disjoint-Set Data Structure
Union-Find Tree
used in SRM505 div.2 900
"""
def __init__(self, n):
self.par = list(range(n)) # parent
self.rank = [0] * n # depth of tree
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y: return
if self.rank[x] < self.rank[y]:
self.par[x] = y
else:
self.par[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def same(self, x, y):
return self.find(x) == self.find(y)
class Kruskal:
""" Kruskal's algorithm: find minimum spanning tree
Complexity: O(E log(V))
used in GRL2A(AOJ)
"""
def __init__(self, V, E, start=0, INF=10**9):
""" V: the number of vertexes
E: adjacency list (undirected graph)
"""
self.kruskal(V, E)
def kruskal(self, V, E):
edges = []
for v1 in range(V):
for v2, cost in E[v1]:
if v1 < v2: edges.append((cost, v1, v2))
edges.sort()
self.mincost = 0
self.minSpanningTree = []
uf = UnionFindTree(V)
for cost, v1, v2 in edges:
if uf.same(v1, v2) == False:
self.mincost += cost
uf.unite(v1, v2)
self.minSpanningTree.append((v1, v2, cost))
def minCost(self):
return self.mincost
def getMinSpanningTree(self):
return sorted(self.minSpanningTree)
V, E = list(map(int, input().split()))
edge = [[] for _ in range(V)]
for _ in range(E):
s, t, w = list(map(int, input().split()))
edge[s].append((t, w))
edge[t].append((s, w))
msp = Kruskal(V, edge)
print((msp.minCost())) | 40 | 74 | 1,051 | 2,004 | from heapq import heappush, heappop
class Prim:
"""find minimum spanning tree by Prim's algorithm"""
def __init__(self, V, E, start=0, INF=10**9):
"""V: the number of vertexes
E: adjacency list (undirected graph)
start: start vertex
INF: Infinity cost
"""
self.prim(V, E, start, INF)
def prim(self, V, E, start=0, INF=10**9):
used = [False] * V
self.mincost = 0
que = []
heappush(que, (0, 0))
while len(que) > 0:
cost, v = heappop(que)
if used[v]:
continue
used[v] = True
self.mincost += cost
for to, c in E[v]:
heappush(que, (c, to))
def minCost(self):
return self.mincost
V, E = list(map(int, input().split()))
edge = [[] for _ in range(V)]
for _ in range(E):
s, t, w = list(map(int, input().split()))
edge[s].append((t, w))
edge[t].append((s, w))
msp = Prim(V, edge)
print((msp.minCost()))
| class UnionFindTree:
"""Disjoint-Set Data Structure
Union-Find Tree
used in SRM505 div.2 900
"""
def __init__(self, n):
self.par = list(range(n)) # parent
self.rank = [0] * n # depth of tree
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.rank[x] < self.rank[y]:
self.par[x] = y
else:
self.par[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def same(self, x, y):
return self.find(x) == self.find(y)
class Kruskal:
"""Kruskal's algorithm: find minimum spanning tree
Complexity: O(E log(V))
used in GRL2A(AOJ)
"""
def __init__(self, V, E, start=0, INF=10**9):
"""V: the number of vertexes
E: adjacency list (undirected graph)
"""
self.kruskal(V, E)
def kruskal(self, V, E):
edges = []
for v1 in range(V):
for v2, cost in E[v1]:
if v1 < v2:
edges.append((cost, v1, v2))
edges.sort()
self.mincost = 0
self.minSpanningTree = []
uf = UnionFindTree(V)
for cost, v1, v2 in edges:
if uf.same(v1, v2) == False:
self.mincost += cost
uf.unite(v1, v2)
self.minSpanningTree.append((v1, v2, cost))
def minCost(self):
return self.mincost
def getMinSpanningTree(self):
return sorted(self.minSpanningTree)
V, E = list(map(int, input().split()))
edge = [[] for _ in range(V)]
for _ in range(E):
s, t, w = list(map(int, input().split()))
edge[s].append((t, w))
edge[t].append((s, w))
msp = Kruskal(V, edge)
print((msp.minCost()))
| false | 45.945946 | [
"-from heapq import heappush, heappop",
"+class UnionFindTree:",
"+ \"\"\"Disjoint-Set Data Structure",
"+ Union-Find Tree",
"+ used in SRM505 div.2 900",
"+ \"\"\"",
"+",
"+ def __init__(self, n):",
"+ self.par = list(range(n)) # parent",
"+ self.rank = [0] * n # depth of tree",
"+",
"+ def find(self, x):",
"+ if self.par[x] == x:",
"+ return x",
"+ else:",
"+ self.par[x] = self.find(self.par[x])",
"+ return self.par[x]",
"+",
"+ def unite(self, x, y):",
"+ x = self.find(x)",
"+ y = self.find(y)",
"+ if x == y:",
"+ return",
"+ if self.rank[x] < self.rank[y]:",
"+ self.par[x] = y",
"+ else:",
"+ self.par[y] = x",
"+ if self.rank[x] == self.rank[y]:",
"+ self.rank[x] += 1",
"+",
"+ def same(self, x, y):",
"+ return self.find(x) == self.find(y)",
"-class Prim:",
"- \"\"\"find minimum spanning tree by Prim's algorithm\"\"\"",
"+class Kruskal:",
"+ \"\"\"Kruskal's algorithm: find minimum spanning tree",
"+ Complexity: O(E log(V))",
"+ used in GRL2A(AOJ)",
"+ \"\"\"",
"- start: start vertex",
"- INF: Infinity cost",
"- self.prim(V, E, start, INF)",
"+ self.kruskal(V, E)",
"- def prim(self, V, E, start=0, INF=10**9):",
"- used = [False] * V",
"+ def kruskal(self, V, E):",
"+ edges = []",
"+ for v1 in range(V):",
"+ for v2, cost in E[v1]:",
"+ if v1 < v2:",
"+ edges.append((cost, v1, v2))",
"+ edges.sort()",
"- que = []",
"- heappush(que, (0, 0))",
"- while len(que) > 0:",
"- cost, v = heappop(que)",
"- if used[v]:",
"- continue",
"- used[v] = True",
"- self.mincost += cost",
"- for to, c in E[v]:",
"- heappush(que, (c, to))",
"+ self.minSpanningTree = []",
"+ uf = UnionFindTree(V)",
"+ for cost, v1, v2 in edges:",
"+ if uf.same(v1, v2) == False:",
"+ self.mincost += cost",
"+ uf.unite(v1, v2)",
"+ self.minSpanningTree.append((v1, v2, cost))",
"+",
"+ def getMinSpanningTree(self):",
"+ return sorted(self.minSpanningTree)",
"-msp = Prim(V, edge)",
"+msp = Kruskal(V, edge)"
] | false | 0.041733 | 0.041148 | 1.014227 | [
"s864133185",
"s386144746"
] |
u257374434 | p02750 | python | s195768974 | s103159034 | 1,655 | 1,232 | 107,352 | 101,852 | Accepted | Accepted | 25.56 | import bisect
N, T = list(map(int, input().split()))
AB = [list(map(int, input().split())) for _ in range(N)]
"""
a_x = 1 and b_x is t_i = 2*(t_i +2)
n 店舗回るのに 2^nはかかる
30店舗以上は回れない
"""
a0 = []
nab = []
for a, b in AB:
if a == 0:
a0.append(b)
else:
nab.append(((b + 1) / a, a, b))
a0.sort()
nab.sort()
a0sum = [] # key: n of visit, value : cost
_sum = 0
for b in a0:
_sum += 1 + b
a0sum.append(_sum)
INF = 1 << 32
dp = [0] + [INF] * 29
for index, (_, a, b) in enumerate(nab):
# print(a, b)
ndp = [0] + [INF] * 29
for count in range(1, 29):
ndp[count] = min(dp[count],
dp[count - 1] + 1 + (dp[count - 1] + 1) * a + b)
dp = ndp
ans = 0
# print(a0sum)
# print(nab)
# print(dp)
for count, t in enumerate(dp):
if t > T:
continue
v = bisect.bisect_right(a0sum, T - t)
ans = max(ans, v + count)
print(ans)
| import bisect
import sys
input = sys.stdin.readline
N, T = list(map(int, input().split()))
AB = [list(map(int, input().split())) for _ in range(N)]
"""
a_x = 1 and b_x is t_i = 2*(t_i +2)
n 店舗回るのに 2^nはかかる
30店舗以上は回れない
"""
a0 = []
nab = []
for a, b in AB:
if a == 0:
a0.append(b)
else:
nab.append(((b + 1) / a, a, b))
a0.sort()
nab.sort()
a0sum = [] # key: n of visit, value : cost
_sum = 0
for b in a0:
_sum += 1 + b
a0sum.append(_sum)
INF = 1 << 32
dp = [0] + [INF] * 29
for index, (_, a, b) in enumerate(nab):
# print(a, b)
ndp = [0] + [INF] * 29
for count in range(1, 29):
ndp[count] = min(dp[count],
dp[count - 1] + 1 + (dp[count - 1] + 1) * a + b)
dp = ndp
ans = 0
# print(a0sum)
# print(nab)
# print(dp)
for count, t in enumerate(dp):
if t > T:
continue
v = bisect.bisect_right(a0sum, T - t)
ans = max(ans, v + count)
print(ans)
| 48 | 49 | 953 | 991 | import bisect
N, T = list(map(int, input().split()))
AB = [list(map(int, input().split())) for _ in range(N)]
"""
a_x = 1 and b_x is t_i = 2*(t_i +2)
n 店舗回るのに 2^nはかかる
30店舗以上は回れない
"""
a0 = []
nab = []
for a, b in AB:
if a == 0:
a0.append(b)
else:
nab.append(((b + 1) / a, a, b))
a0.sort()
nab.sort()
a0sum = [] # key: n of visit, value : cost
_sum = 0
for b in a0:
_sum += 1 + b
a0sum.append(_sum)
INF = 1 << 32
dp = [0] + [INF] * 29
for index, (_, a, b) in enumerate(nab):
# print(a, b)
ndp = [0] + [INF] * 29
for count in range(1, 29):
ndp[count] = min(dp[count], dp[count - 1] + 1 + (dp[count - 1] + 1) * a + b)
dp = ndp
ans = 0
# print(a0sum)
# print(nab)
# print(dp)
for count, t in enumerate(dp):
if t > T:
continue
v = bisect.bisect_right(a0sum, T - t)
ans = max(ans, v + count)
print(ans)
| import bisect
import sys
input = sys.stdin.readline
N, T = list(map(int, input().split()))
AB = [list(map(int, input().split())) for _ in range(N)]
"""
a_x = 1 and b_x is t_i = 2*(t_i +2)
n 店舗回るのに 2^nはかかる
30店舗以上は回れない
"""
a0 = []
nab = []
for a, b in AB:
if a == 0:
a0.append(b)
else:
nab.append(((b + 1) / a, a, b))
a0.sort()
nab.sort()
a0sum = [] # key: n of visit, value : cost
_sum = 0
for b in a0:
_sum += 1 + b
a0sum.append(_sum)
INF = 1 << 32
dp = [0] + [INF] * 29
for index, (_, a, b) in enumerate(nab):
# print(a, b)
ndp = [0] + [INF] * 29
for count in range(1, 29):
ndp[count] = min(dp[count], dp[count - 1] + 1 + (dp[count - 1] + 1) * a + b)
dp = ndp
ans = 0
# print(a0sum)
# print(nab)
# print(dp)
for count, t in enumerate(dp):
if t > T:
continue
v = bisect.bisect_right(a0sum, T - t)
ans = max(ans, v + count)
print(ans)
| false | 2.040816 | [
"+import sys",
"+input = sys.stdin.readline"
] | false | 0.088861 | 0.210012 | 0.423124 | [
"s195768974",
"s103159034"
] |
u429029348 | p02607 | python | s317805534 | s945161647 | 30 | 26 | 9,180 | 9,096 | Accepted | Accepted | 13.33 | n=int(eval(input()))
a=list(map(int,input().split()))
b=a[::2]
cnt=0
for i in range(len(b)):
if b[i]%2==1:
cnt+=1
print(cnt) | n = int(eval(input()))
a = list(map(int, input().split()))
aa = a[::2]
cnt = 0
for i in aa:
if i % 2 == 1:
cnt += 1
print(cnt)
| 8 | 10 | 131 | 144 | n = int(eval(input()))
a = list(map(int, input().split()))
b = a[::2]
cnt = 0
for i in range(len(b)):
if b[i] % 2 == 1:
cnt += 1
print(cnt)
| n = int(eval(input()))
a = list(map(int, input().split()))
aa = a[::2]
cnt = 0
for i in aa:
if i % 2 == 1:
cnt += 1
print(cnt)
| false | 20 | [
"-b = a[::2]",
"+aa = a[::2]",
"-for i in range(len(b)):",
"- if b[i] % 2 == 1:",
"+for i in aa:",
"+ if i % 2 == 1:"
] | false | 0.067595 | 0.032795 | 2.061141 | [
"s317805534",
"s945161647"
] |
u263830634 | p02868 | python | s782608975 | s263789113 | 1,454 | 1,266 | 100,332 | 97,148 | Accepted | Accepted | 12.93 | INF = 10 ** 18
N, M = list(map(int, input().split()))
G = [[] for _ in range(N + 1)]
for _ in range(M):
L, R, C = list(map(int, input().split()))
G[L].append([C, R])
G[R].append([C, L])
for i in range(1, N):
G[i + 1].append([0, i])
d = [INF] * (N + 1)
def dijkstra(s):
import heapq
d[s] = 0
pque = []
heapq.heappush(pque, [0, s])
while pque:
p = heapq.heappop(pque)
v = p[1]
if d[v] < p[0]:
continue
for i in range(len(G[v])):
e = G[v][i]
if d[e[1]] > d[v] + e[0]:
d[e[1]] = d[v] + e[0]
heapq.heappush(pque, [d[e[1]], e[1]])
dijkstra(1)
print((-1 if d[-1] == INF else d[-1])) | def main():
import sys
input = sys.stdin.readline
INF = 10 ** 18
N, M = list(map(int, input().split()))
G = [[] for _ in range(N + 1)]
for _ in range(M):
L, R, C = list(map(int, input().split()))
G[L].append([C, R])
G[R].append([C, L])
for i in range(1, N):
G[i + 1].append([0, i])
d = [INF] * (N + 1)
def dijkstra(s):
from heapq import heappop, heappush
d[s] = 0
pque = []
heappush(pque, [0, s])
while pque:
p = heappop(pque)
v = p[1]
if d[v] < p[0]:
continue
for i in range(len(G[v])):
e = G[v][i]
if d[e[1]] > d[v] + e[0]:
d[e[1]] = d[v] + e[0]
heappush(pque, [d[e[1]], e[1]])
dijkstra(1)
print((-1 if d[-1] == INF else d[-1]))
if __name__ == '__main__':
main() | 35 | 42 | 744 | 966 | INF = 10**18
N, M = list(map(int, input().split()))
G = [[] for _ in range(N + 1)]
for _ in range(M):
L, R, C = list(map(int, input().split()))
G[L].append([C, R])
G[R].append([C, L])
for i in range(1, N):
G[i + 1].append([0, i])
d = [INF] * (N + 1)
def dijkstra(s):
import heapq
d[s] = 0
pque = []
heapq.heappush(pque, [0, s])
while pque:
p = heapq.heappop(pque)
v = p[1]
if d[v] < p[0]:
continue
for i in range(len(G[v])):
e = G[v][i]
if d[e[1]] > d[v] + e[0]:
d[e[1]] = d[v] + e[0]
heapq.heappush(pque, [d[e[1]], e[1]])
dijkstra(1)
print((-1 if d[-1] == INF else d[-1]))
| def main():
import sys
input = sys.stdin.readline
INF = 10**18
N, M = list(map(int, input().split()))
G = [[] for _ in range(N + 1)]
for _ in range(M):
L, R, C = list(map(int, input().split()))
G[L].append([C, R])
G[R].append([C, L])
for i in range(1, N):
G[i + 1].append([0, i])
d = [INF] * (N + 1)
def dijkstra(s):
from heapq import heappop, heappush
d[s] = 0
pque = []
heappush(pque, [0, s])
while pque:
p = heappop(pque)
v = p[1]
if d[v] < p[0]:
continue
for i in range(len(G[v])):
e = G[v][i]
if d[e[1]] > d[v] + e[0]:
d[e[1]] = d[v] + e[0]
heappush(pque, [d[e[1]], e[1]])
dijkstra(1)
print((-1 if d[-1] == INF else d[-1]))
if __name__ == "__main__":
main()
| false | 16.666667 | [
"-INF = 10**18",
"-N, M = list(map(int, input().split()))",
"-G = [[] for _ in range(N + 1)]",
"-for _ in range(M):",
"- L, R, C = list(map(int, input().split()))",
"- G[L].append([C, R])",
"- G[R].append([C, L])",
"-for i in range(1, N):",
"- G[i + 1].append([0, i])",
"-d = [INF] * (N + 1)",
"+def main():",
"+ import sys",
"+",
"+ input = sys.stdin.readline",
"+ INF = 10**18",
"+ N, M = list(map(int, input().split()))",
"+ G = [[] for _ in range(N + 1)]",
"+ for _ in range(M):",
"+ L, R, C = list(map(int, input().split()))",
"+ G[L].append([C, R])",
"+ G[R].append([C, L])",
"+ for i in range(1, N):",
"+ G[i + 1].append([0, i])",
"+ d = [INF] * (N + 1)",
"+",
"+ def dijkstra(s):",
"+ from heapq import heappop, heappush",
"+",
"+ d[s] = 0",
"+ pque = []",
"+ heappush(pque, [0, s])",
"+ while pque:",
"+ p = heappop(pque)",
"+ v = p[1]",
"+ if d[v] < p[0]:",
"+ continue",
"+ for i in range(len(G[v])):",
"+ e = G[v][i]",
"+ if d[e[1]] > d[v] + e[0]:",
"+ d[e[1]] = d[v] + e[0]",
"+ heappush(pque, [d[e[1]], e[1]])",
"+",
"+ dijkstra(1)",
"+ print((-1 if d[-1] == INF else d[-1]))",
"-def dijkstra(s):",
"- import heapq",
"-",
"- d[s] = 0",
"- pque = []",
"- heapq.heappush(pque, [0, s])",
"- while pque:",
"- p = heapq.heappop(pque)",
"- v = p[1]",
"- if d[v] < p[0]:",
"- continue",
"- for i in range(len(G[v])):",
"- e = G[v][i]",
"- if d[e[1]] > d[v] + e[0]:",
"- d[e[1]] = d[v] + e[0]",
"- heapq.heappush(pque, [d[e[1]], e[1]])",
"-",
"-",
"-dijkstra(1)",
"-print((-1 if d[-1] == INF else d[-1]))",
"+if __name__ == \"__main__\":",
"+ main()"
] | false | 0.046801 | 0.08877 | 0.527216 | [
"s782608975",
"s263789113"
] |
u823513038 | p02389 | python | s812434608 | s865368070 | 30 | 20 | 7,644 | 5,584 | Accepted | Accepted | 33.33 | a, b = list(map(int, input().split()))
print((a * b, 2 * a + 2 * b)) | a, b = list(map(int, input().split()))
print((a * b, (a + b) * 2))
| 2 | 2 | 61 | 60 | a, b = list(map(int, input().split()))
print((a * b, 2 * a + 2 * b))
| a, b = list(map(int, input().split()))
print((a * b, (a + b) * 2))
| false | 0 | [
"-print((a * b, 2 * a + 2 * b))",
"+print((a * b, (a + b) * 2))"
] | false | 0.046923 | 0.04695 | 0.999423 | [
"s812434608",
"s865368070"
] |
u838644735 | p03546 | python | s392083136 | s058252624 | 1,950 | 34 | 3,444 | 3,444 | Accepted | Accepted | 98.26 | def calc_mp(C, candidates, n, ans):
for i in range(len(candidates)):
candidates2 = [c for c in candidates]
c = candidates[i]
del candidates2[i]
a = C[n][c]
if c != 1:
a += calc_mp(C, candidates2, c, ans)
ans = min(a, ans)
return ans
def main():
H, W = list(map(int, input().split()))
C = [0]*10
for i in range(10):
C[i] = list(map(int, input().split()))
A = [0]*H
for i in range(H):
A[i] = list(map(int, input().split()))
# print(H, W, C, A)
MPs = [0]*10
for i in range(10):
if i != 1:
candidates = [j for j in range(10)]
del(candidates[i])
MPs[i] = calc_mp(C, candidates, i, 1000)
# print(MPs)
ans = 0
for h in range(H):
for w in range(W):
a = A[h][w]
if a != -1:
ans += MPs[a]
print(ans)
if __name__ == '__main__':
main()
| def calc_mp(C, d):
for k in range(10):
for i in range(10):
for j in range(10):
if k == 0:
d[i][j][k] = min(C[i][j], C[i][k] + C[k][j])
else:
d[i][j][k] = min(d[i][j][k-1], d[i][k][k-1] + d[k][j][k-1])
def main():
H, W = list(map(int, input().split()))
C = [0]*10
for i in range(10):
C[i] = list(map(int, input().split()))
A = [0]*H
for i in range(H):
A[i] = list(map(int, input().split()))
# print(H, W, C, A)
d = [[[0 for i in range(10)] for i in range(10)] for i in range(10)]
calc_mp(C, d)
# print(d)
ans = 0
for h in range(H):
for w in range(W):
a = A[h][w]
if a != -1 and a != 1:
ans += d[a][1][9]
print(ans)
if __name__ == '__main__':
main()
| 38 | 33 | 986 | 890 | def calc_mp(C, candidates, n, ans):
for i in range(len(candidates)):
candidates2 = [c for c in candidates]
c = candidates[i]
del candidates2[i]
a = C[n][c]
if c != 1:
a += calc_mp(C, candidates2, c, ans)
ans = min(a, ans)
return ans
def main():
H, W = list(map(int, input().split()))
C = [0] * 10
for i in range(10):
C[i] = list(map(int, input().split()))
A = [0] * H
for i in range(H):
A[i] = list(map(int, input().split()))
# print(H, W, C, A)
MPs = [0] * 10
for i in range(10):
if i != 1:
candidates = [j for j in range(10)]
del candidates[i]
MPs[i] = calc_mp(C, candidates, i, 1000)
# print(MPs)
ans = 0
for h in range(H):
for w in range(W):
a = A[h][w]
if a != -1:
ans += MPs[a]
print(ans)
if __name__ == "__main__":
main()
| def calc_mp(C, d):
for k in range(10):
for i in range(10):
for j in range(10):
if k == 0:
d[i][j][k] = min(C[i][j], C[i][k] + C[k][j])
else:
d[i][j][k] = min(d[i][j][k - 1], d[i][k][k - 1] + d[k][j][k - 1])
def main():
H, W = list(map(int, input().split()))
C = [0] * 10
for i in range(10):
C[i] = list(map(int, input().split()))
A = [0] * H
for i in range(H):
A[i] = list(map(int, input().split()))
# print(H, W, C, A)
d = [[[0 for i in range(10)] for i in range(10)] for i in range(10)]
calc_mp(C, d)
# print(d)
ans = 0
for h in range(H):
for w in range(W):
a = A[h][w]
if a != -1 and a != 1:
ans += d[a][1][9]
print(ans)
if __name__ == "__main__":
main()
| false | 13.157895 | [
"-def calc_mp(C, candidates, n, ans):",
"- for i in range(len(candidates)):",
"- candidates2 = [c for c in candidates]",
"- c = candidates[i]",
"- del candidates2[i]",
"- a = C[n][c]",
"- if c != 1:",
"- a += calc_mp(C, candidates2, c, ans)",
"- ans = min(a, ans)",
"- return ans",
"+def calc_mp(C, d):",
"+ for k in range(10):",
"+ for i in range(10):",
"+ for j in range(10):",
"+ if k == 0:",
"+ d[i][j][k] = min(C[i][j], C[i][k] + C[k][j])",
"+ else:",
"+ d[i][j][k] = min(d[i][j][k - 1], d[i][k][k - 1] + d[k][j][k - 1])",
"- MPs = [0] * 10",
"- for i in range(10):",
"- if i != 1:",
"- candidates = [j for j in range(10)]",
"- del candidates[i]",
"- MPs[i] = calc_mp(C, candidates, i, 1000)",
"- # print(MPs)",
"+ d = [[[0 for i in range(10)] for i in range(10)] for i in range(10)]",
"+ calc_mp(C, d)",
"+ # print(d)",
"- if a != -1:",
"- ans += MPs[a]",
"+ if a != -1 and a != 1:",
"+ ans += d[a][1][9]"
] | false | 2.712456 | 0.049556 | 54.735663 | [
"s392083136",
"s058252624"
] |
u784022244 | p02631 | python | s323216385 | s200205157 | 203 | 187 | 94,264 | 105,632 | Accepted | Accepted | 7.88 | N=int(input())
A=list(map(int, input().split()))
"""
20 10100 11010
11 01011 00101
9 01001 00111
24 11000 10110
"""
for i in range(N):
if i==0:
now=A[0]
else:
now=now^A[i]
for i in range(N):
ans=now^A[i]
print(ans, end=" ")
| N=int(input())
A=list(map(int, input().split()))
now=A[0]
for i in range(1,N):
now=now^A[i]
for i in range(N):
print(now^A[i], end=" ")
| 16 | 8 | 271 | 151 | N = int(input())
A = list(map(int, input().split()))
"""
20 10100 11010
11 01011 00101
9 01001 00111
24 11000 10110
"""
for i in range(N):
if i == 0:
now = A[0]
else:
now = now ^ A[i]
for i in range(N):
ans = now ^ A[i]
print(ans, end=" ")
| N = int(input())
A = list(map(int, input().split()))
now = A[0]
for i in range(1, N):
now = now ^ A[i]
for i in range(N):
print(now ^ A[i], end=" ")
| false | 50 | [
"-\"\"\"",
"-20 10100 11010",
"-11 01011 00101",
"-9 01001 00111",
"-24 11000 10110",
"-\"\"\"",
"+now = A[0]",
"+for i in range(1, N):",
"+ now = now ^ A[i]",
"- if i == 0:",
"- now = A[0]",
"- else:",
"- now = now ^ A[i]",
"-for i in range(N):",
"- ans = now ^ A[i]",
"- print(ans, end=\" \")",
"+ print(now ^ A[i], end=\" \")"
] | false | 0.040762 | 0.041 | 0.9942 | [
"s323216385",
"s200205157"
] |
u145950990 | p02983 | python | s261354643 | s425247216 | 1,549 | 673 | 3,064 | 9,136 | Accepted | Accepted | 56.55 | l,r = list(map(int,input().split()))
ans = 2019
for i in range(l,min(l+2019,r)):
for j in range(l+1,min(l+2019,r+1)):
ans = min(ans,i*j%2019)
print(ans) | l,r = list(map(int,input().split()))
r = min(r,l+2019)
ans = 2019
for i in range(l,r+1):
for j in range(i+1,r+1):
ans = min(ans,i*j%2019)
print(ans) | 6 | 7 | 163 | 160 | l, r = list(map(int, input().split()))
ans = 2019
for i in range(l, min(l + 2019, r)):
for j in range(l + 1, min(l + 2019, r + 1)):
ans = min(ans, i * j % 2019)
print(ans)
| l, r = list(map(int, input().split()))
r = min(r, l + 2019)
ans = 2019
for i in range(l, r + 1):
for j in range(i + 1, r + 1):
ans = min(ans, i * j % 2019)
print(ans)
| false | 14.285714 | [
"+r = min(r, l + 2019)",
"-for i in range(l, min(l + 2019, r)):",
"- for j in range(l + 1, min(l + 2019, r + 1)):",
"+for i in range(l, r + 1):",
"+ for j in range(i + 1, r + 1):"
] | false | 0.14054 | 0.079551 | 1.766657 | [
"s261354643",
"s425247216"
] |
u761320129 | p02626 | python | s807251602 | s026491340 | 32 | 26 | 9,188 | 9,184 | Accepted | Accepted | 18.75 | N = int(eval(input()))
A,B,*C = list(map(int,input().split()))
X = 0
for c in C:
X ^= c
S = A+B
K = 43
dp = [[[-1]*2 for _ in range(2)] for _ in range(K)]
dp[0][0][0] = 0
for i in range(K-1):
cx = (X>>i)&1
cs = (S>>i)&1
ca = (A>>i)&1
for j in range(2):
for k in range(2):
if dp[i][j][k] == -1: continue
for na in range(2):
for nb in range(2):
if (na^nb) != cx: continue
ns = na+nb+j
if ns%2 != cs: continue
nj = ns//2
if ca < na:
nk = 1
elif ca == na:
nk = k
else:
nk = 0
dp[i+1][nj][nk] = max(dp[i+1][nj][nk], dp[i][j][k] + 2**i * na)
a = dp[-1][0][0]
if a==0 or a==-1:
print((-1))
else:
print((A - a)) | N = int(eval(input()))
A,B,*C = list(map(int,input().split()))
X = 0
for c in C:
X ^= c
S = A+B
K = 43
dp = [[[-1]*2 for _ in range(2)] for _ in range(K)]
dp[0][0][0] = 0
for i in range(K-1):
cx = (X>>i)&1
cs = (S>>i)&1
ca = (A>>i)&1
for j in range(2):
for k in range(2):
if dp[i][j][k] == -1: continue
for na in range(2):
nb = na^cx
ns = na+nb+j
if ns%2 != cs: continue
nj = ns//2
if ca < na:
nk = 1
elif ca == na:
nk = k
else:
nk = 0
dp[i+1][nj][nk] = max(dp[i+1][nj][nk], dp[i][j][k] + 2**i * na)
a = dp[-1][0][0]
if a==0 or a==-1:
print((-1))
else:
print((A - a)) | 36 | 35 | 938 | 841 | N = int(eval(input()))
A, B, *C = list(map(int, input().split()))
X = 0
for c in C:
X ^= c
S = A + B
K = 43
dp = [[[-1] * 2 for _ in range(2)] for _ in range(K)]
dp[0][0][0] = 0
for i in range(K - 1):
cx = (X >> i) & 1
cs = (S >> i) & 1
ca = (A >> i) & 1
for j in range(2):
for k in range(2):
if dp[i][j][k] == -1:
continue
for na in range(2):
for nb in range(2):
if (na ^ nb) != cx:
continue
ns = na + nb + j
if ns % 2 != cs:
continue
nj = ns // 2
if ca < na:
nk = 1
elif ca == na:
nk = k
else:
nk = 0
dp[i + 1][nj][nk] = max(
dp[i + 1][nj][nk], dp[i][j][k] + 2**i * na
)
a = dp[-1][0][0]
if a == 0 or a == -1:
print((-1))
else:
print((A - a))
| N = int(eval(input()))
A, B, *C = list(map(int, input().split()))
X = 0
for c in C:
X ^= c
S = A + B
K = 43
dp = [[[-1] * 2 for _ in range(2)] for _ in range(K)]
dp[0][0][0] = 0
for i in range(K - 1):
cx = (X >> i) & 1
cs = (S >> i) & 1
ca = (A >> i) & 1
for j in range(2):
for k in range(2):
if dp[i][j][k] == -1:
continue
for na in range(2):
nb = na ^ cx
ns = na + nb + j
if ns % 2 != cs:
continue
nj = ns // 2
if ca < na:
nk = 1
elif ca == na:
nk = k
else:
nk = 0
dp[i + 1][nj][nk] = max(dp[i + 1][nj][nk], dp[i][j][k] + 2**i * na)
a = dp[-1][0][0]
if a == 0 or a == -1:
print((-1))
else:
print((A - a))
| false | 2.777778 | [
"- for nb in range(2):",
"- if (na ^ nb) != cx:",
"- continue",
"- ns = na + nb + j",
"- if ns % 2 != cs:",
"- continue",
"- nj = ns // 2",
"- if ca < na:",
"- nk = 1",
"- elif ca == na:",
"- nk = k",
"- else:",
"- nk = 0",
"- dp[i + 1][nj][nk] = max(",
"- dp[i + 1][nj][nk], dp[i][j][k] + 2**i * na",
"- )",
"+ nb = na ^ cx",
"+ ns = na + nb + j",
"+ if ns % 2 != cs:",
"+ continue",
"+ nj = ns // 2",
"+ if ca < na:",
"+ nk = 1",
"+ elif ca == na:",
"+ nk = k",
"+ else:",
"+ nk = 0",
"+ dp[i + 1][nj][nk] = max(dp[i + 1][nj][nk], dp[i][j][k] + 2**i * na)"
] | false | 0.040451 | 0.040246 | 1.005084 | [
"s807251602",
"s026491340"
] |
u600402037 | p02845 | python | s381241139 | s556890231 | 318 | 120 | 14,008 | 14,008 | Accepted | Accepted | 62.26 | import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N = ir()
A = lr()
hat = [0, 0, 0]
MOD = 10 ** 9 + 7
answer = 1
for i in range(N):
x = hat.count(A[i])
if x == 0:
answer = 0
else:
answer *= x
j = hat.index(A[i])
hat[j] += 1
print((answer%MOD))
# 30 | import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N = ir()
A = lr()
hat = [0, 0, 0]
MOD = 10 ** 9 + 7
answer = 1
for i in range(N):
x = hat.count(A[i])
if x == 0:
answer = 0
else:
answer *= x
j = hat.index(A[i])
hat[j] += 1
answer %= MOD
print((answer%MOD))
# 30
| 22 | 23 | 383 | 407 | import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N = ir()
A = lr()
hat = [0, 0, 0]
MOD = 10**9 + 7
answer = 1
for i in range(N):
x = hat.count(A[i])
if x == 0:
answer = 0
else:
answer *= x
j = hat.index(A[i])
hat[j] += 1
print((answer % MOD))
# 30
| import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N = ir()
A = lr()
hat = [0, 0, 0]
MOD = 10**9 + 7
answer = 1
for i in range(N):
x = hat.count(A[i])
if x == 0:
answer = 0
else:
answer *= x
j = hat.index(A[i])
hat[j] += 1
answer %= MOD
print((answer % MOD))
# 30
| false | 4.347826 | [
"+ answer %= MOD"
] | false | 0.037828 | 0.037174 | 1.017585 | [
"s381241139",
"s556890231"
] |
u687135117 | p02693 | python | s403302813 | s438533591 | 22 | 19 | 9,108 | 9,108 | Accepted | Accepted | 13.64 | #import collections
# c = collections.Counter()
#import itertools as it
#import math
#import numpy as np
#import sys
#sys.exit()
# = input()
k = int(eval(input()))
a, b = list(map(int, input().split()))
'''
# = list(map(int, input().split()))
'''
'''
n = input()
a = [int(input()) for i in range(n)]
'''
'''
n,m = map(int, input().split())
a = [list(map(int, input().split())) for _ in range(m)]
'''
#-------------------------------#
if a%k==0 or b%k==0 or a//k!=b//k:
print('OK')
else:
print('NG') | k = int(eval(input()))
a,b = list(map(int, input().split()))
if a%k==0 or b%k==0 or a//k!=b//k:
print('OK')
else:
print('NG') | 29 | 7 | 527 | 125 | # import collections
# c = collections.Counter()
# import itertools as it
# import math
# import numpy as np
# import sys
# sys.exit()
# = input()
k = int(eval(input()))
a, b = list(map(int, input().split()))
"""
# = list(map(int, input().split()))
"""
"""
n = input()
a = [int(input()) for i in range(n)]
"""
"""
n,m = map(int, input().split())
a = [list(map(int, input().split())) for _ in range(m)]
"""
# -------------------------------#
if a % k == 0 or b % k == 0 or a // k != b // k:
print("OK")
else:
print("NG")
| k = int(eval(input()))
a, b = list(map(int, input().split()))
if a % k == 0 or b % k == 0 or a // k != b // k:
print("OK")
else:
print("NG")
| false | 75.862069 | [
"-# import collections",
"-# c = collections.Counter()",
"-# import itertools as it",
"-# import math",
"-# import numpy as np",
"-# import sys",
"-# sys.exit()",
"-# = input()",
"-\"\"\"",
"-# = list(map(int, input().split()))",
"-\"\"\"",
"-\"\"\"",
"-n = input()",
"-a = [int(input()) for i in range(n)]",
"-\"\"\"",
"-\"\"\"",
"-n,m = map(int, input().split())",
"-a = [list(map(int, input().split())) for _ in range(m)]",
"-\"\"\""
] | false | 0.070715 | 0.037561 | 1.882686 | [
"s403302813",
"s438533591"
] |
u841623074 | p03608 | python | s297115580 | s348092998 | 832 | 647 | 28,100 | 18,528 | Accepted | Accepted | 22.24 | from itertools import permutations as p
from scipy.sparse.csgraph import floyd_warshall
n, m, r = list(map(int, input().split()))
R = list(map(int, input().split()))
l = [[0]*n for _ in range(n)]
for _ in range(m):
a, b, c = list(map(int, input().split()))
a -= 1
b -= 1
l[a][b] = c
l[b][a] = c
F = floyd_warshall(l)
ans = float("inf")
for v in p(R):
temp = 0
for i in range(r-1):
temp += F[v[i]-1][v[i+1]-1]
ans = min(ans, temp)
print((int(ans))) | from itertools import permutations
from scipy.sparse.csgraph import floyd_warshall
n,m,r=list(map(int,input().split()))
R=list(map(int,input().split()))
l=[[float('inf')]*n for _ in range(n)]
for _ in range(m):
a,b,c,=list(map(int,input().split()))
a-=1
b-=1
l[a][b]=c
l[b][a]=c
for i in range(n):
l[i][i] = 0 #自身のところに行くコストは０
def warshall_floyd(d):
for k in range(n):
for i in range(n):
for j in range(n):
d[i][j]=min(d[i][j],d[i][k]+d[k][j])
return d
#F=warshall_floyd(l)
F1 = floyd_warshall(l)
ans=float('inf')
for v in permutations(R):
temp=0
for i in range(r-1):
temp+=F1[v[i]-1][v[i+1]-1]
ans=min(ans,temp)
print((int(ans))) | 22 | 29 | 500 | 748 | from itertools import permutations as p
from scipy.sparse.csgraph import floyd_warshall
n, m, r = list(map(int, input().split()))
R = list(map(int, input().split()))
l = [[0] * n for _ in range(n)]
for _ in range(m):
a, b, c = list(map(int, input().split()))
a -= 1
b -= 1
l[a][b] = c
l[b][a] = c
F = floyd_warshall(l)
ans = float("inf")
for v in p(R):
temp = 0
for i in range(r - 1):
temp += F[v[i] - 1][v[i + 1] - 1]
ans = min(ans, temp)
print((int(ans)))
| from itertools import permutations
from scipy.sparse.csgraph import floyd_warshall
n, m, r = list(map(int, input().split()))
R = list(map(int, input().split()))
l = [[float("inf")] * n for _ in range(n)]
for _ in range(m):
(
a,
b,
c,
) = list(map(int, input().split()))
a -= 1
b -= 1
l[a][b] = c
l[b][a] = c
for i in range(n):
l[i][i] = 0 # 自身のところに行くコストは０
def warshall_floyd(d):
for k in range(n):
for i in range(n):
for j in range(n):
d[i][j] = min(d[i][j], d[i][k] + d[k][j])
return d
# F=warshall_floyd(l)
F1 = floyd_warshall(l)
ans = float("inf")
for v in permutations(R):
temp = 0
for i in range(r - 1):
temp += F1[v[i] - 1][v[i + 1] - 1]
ans = min(ans, temp)
print((int(ans)))
| false | 24.137931 | [
"-from itertools import permutations as p",
"+from itertools import permutations",
"-l = [[0] * n for _ in range(n)]",
"+l = [[float(\"inf\")] * n for _ in range(n)]",
"- a, b, c = list(map(int, input().split()))",
"+ (",
"+ a,",
"+ b,",
"+ c,",
"+ ) = list(map(int, input().split()))",
"-F = floyd_warshall(l)",
"+for i in range(n):",
"+ l[i][i] = 0 # 自身のところに行くコストは０",
"+",
"+",
"+def warshall_floyd(d):",
"+ for k in range(n):",
"+ for i in range(n):",
"+ for j in range(n):",
"+ d[i][j] = min(d[i][j], d[i][k] + d[k][j])",
"+ return d",
"+",
"+",
"+# F=warshall_floyd(l)",
"+F1 = floyd_warshall(l)",
"-for v in p(R):",
"+for v in permutations(R):",
"- temp += F[v[i] - 1][v[i + 1] - 1]",
"+ temp += F1[v[i] - 1][v[i + 1] - 1]"
] | false | 0.410212 | 0.303801 | 1.350263 | [
"s297115580",
"s348092998"
] |
u131634965 | p03370 | python | s111447802 | s999846244 | 37 | 17 | 3,064 | 2,940 | Accepted | Accepted | 54.05 | n,x=list(map(int, input().split()))
m=[int(eval(input())) for _ in range(n)]
count=0
for i in range(len(m)):
if x>=m[i]:
x-=m[i]
count+=1
min_donut=min(m)
while(x>=min_donut):
x-=min_donut
count+=1
print(count) | n,x=list(map(int, input().split()))
m=[int(eval(input())) for _ in range(n)]
print(((x-sum(m))//min(m)+n)) | 16 | 4 | 257 | 96 | n, x = list(map(int, input().split()))
m = [int(eval(input())) for _ in range(n)]
count = 0
for i in range(len(m)):
if x >= m[i]:
x -= m[i]
count += 1
min_donut = min(m)
while x >= min_donut:
x -= min_donut
count += 1
print(count)
| n, x = list(map(int, input().split()))
m = [int(eval(input())) for _ in range(n)]
print(((x - sum(m)) // min(m) + n))
| false | 75 | [
"-count = 0",
"-for i in range(len(m)):",
"- if x >= m[i]:",
"- x -= m[i]",
"- count += 1",
"-min_donut = min(m)",
"-while x >= min_donut:",
"- x -= min_donut",
"- count += 1",
"-print(count)",
"+print(((x - sum(m)) // min(m) + n))"
] | false | 0.037596 | 0.081274 | 0.462585 | [
"s111447802",
"s999846244"
] |
u133936772 | p02881 | python | s573278545 | s764916562 | 152 | 131 | 2,940 | 2,940 | Accepted | Accepted | 13.82 | n=int(eval(input()))
for i in range(int(n**.5),0,-1):
if n%i<1: print((i+n//i-2)); break | n=int(eval(input()))
print((min(i+n//i-2 for i in range(1,int(n**.5)+1) if n%i<1))) | 3 | 2 | 84 | 76 | n = int(eval(input()))
for i in range(int(n**0.5), 0, -1):
if n % i < 1:
print((i + n // i - 2))
break
| n = int(eval(input()))
print((min(i + n // i - 2 for i in range(1, int(n**0.5) + 1) if n % i < 1)))
| false | 33.333333 | [
"-for i in range(int(n**0.5), 0, -1):",
"- if n % i < 1:",
"- print((i + n // i - 2))",
"- break",
"+print((min(i + n // i - 2 for i in range(1, int(n**0.5) + 1) if n % i < 1)))"
] | false | 0.047772 | 0.05021 | 0.951439 | [
"s573278545",
"s764916562"
] |
u923270446 | p02685 | python | s882878275 | s950916114 | 1,298 | 278 | 9,236 | 79,600 | Accepted | Accepted | 78.58 | n, m, k = list(map(int, input().split()))
mod = 998244353
ans = 0
x = 1
for i in range(k + 1):
ans += (((m * pow(m - 1, n - i - 1, mod)) % mod) * x) % mod
ans %= mod
x = (x * (n - i - 1) * pow(i + 1, mod - 2, mod)) % mod
print((ans % mod)) | mod = 998244353
def comb(n, r):
if n < r:return 0
if n < 0 or r < 0:return 0
return fa[n] * fi[r] % mod * fi[n - r] % mod
n, m, k = list(map(int, input().split()))
fa = [1] * (n + 1)
fi = [1] * (n + 1)
for i in range(1, n + 1):
fa[i] = fa[i - 1] * i % mod
fi[i] = pow(fa[i], mod - 2, mod)
ans = 0
for i in range(k + 1):
ans += pow(m - 1, n - i - 1, mod) % mod * comb(n - 1, i) * m % mod
ans %= mod
print(ans) | 9 | 16 | 251 | 445 | n, m, k = list(map(int, input().split()))
mod = 998244353
ans = 0
x = 1
for i in range(k + 1):
ans += (((m * pow(m - 1, n - i - 1, mod)) % mod) * x) % mod
ans %= mod
x = (x * (n - i - 1) * pow(i + 1, mod - 2, mod)) % mod
print((ans % mod))
| mod = 998244353
def comb(n, r):
if n < r:
return 0
if n < 0 or r < 0:
return 0
return fa[n] * fi[r] % mod * fi[n - r] % mod
n, m, k = list(map(int, input().split()))
fa = [1] * (n + 1)
fi = [1] * (n + 1)
for i in range(1, n + 1):
fa[i] = fa[i - 1] * i % mod
fi[i] = pow(fa[i], mod - 2, mod)
ans = 0
for i in range(k + 1):
ans += pow(m - 1, n - i - 1, mod) % mod * comb(n - 1, i) * m % mod
ans %= mod
print(ans)
| false | 43.75 | [
"+mod = 998244353",
"+",
"+",
"+def comb(n, r):",
"+ if n < r:",
"+ return 0",
"+ if n < 0 or r < 0:",
"+ return 0",
"+ return fa[n] * fi[r] % mod * fi[n - r] % mod",
"+",
"+",
"-mod = 998244353",
"+fa = [1] * (n + 1)",
"+fi = [1] * (n + 1)",
"+for i in range(1, n + 1):",
"+ fa[i] = fa[i - 1] * i % mod",
"+ fi[i] = pow(fa[i], mod - 2, mod)",
"-x = 1",
"- ans += (((m * pow(m - 1, n - i - 1, mod)) % mod) * x) % mod",
"+ ans += pow(m - 1, n - i - 1, mod) % mod * comb(n - 1, i) * m % mod",
"- x = (x * (n - i - 1) * pow(i + 1, mod - 2, mod)) % mod",
"-print((ans % mod))",
"+print(ans)"
] | false | 0.065686 | 0.128557 | 0.510951 | [
"s882878275",
"s950916114"
] |
u801359367 | p03325 | python | s593307374 | s385216829 | 155 | 104 | 4,148 | 4,152 | Accepted | Accepted | 32.9 | N = int(eval(input()))
A = list(map(int,input().split()))
count_A =[]
for i in range(N):
count = 0
while A[i]%2 == 0:
A[i] = A[i]/2
count += 1
count_A.append(count)
print((sum(count_A))) | N = int(eval(input()))
A = list(map(int,input().split()))
SUM = 0
for i in A:
count = 0
while i%2 == 0:
i = i/2
count += 1
SUM+=count
print(SUM) | 12 | 11 | 219 | 177 | N = int(eval(input()))
A = list(map(int, input().split()))
count_A = []
for i in range(N):
count = 0
while A[i] % 2 == 0:
A[i] = A[i] / 2
count += 1
count_A.append(count)
print((sum(count_A)))
| N = int(eval(input()))
A = list(map(int, input().split()))
SUM = 0
for i in A:
count = 0
while i % 2 == 0:
i = i / 2
count += 1
SUM += count
print(SUM)
| false | 8.333333 | [
"-count_A = []",
"-for i in range(N):",
"+SUM = 0",
"+for i in A:",
"- while A[i] % 2 == 0:",
"- A[i] = A[i] / 2",
"+ while i % 2 == 0:",
"+ i = i / 2",
"- count_A.append(count)",
"-print((sum(count_A)))",
"+ SUM += count",
"+print(SUM)"
] | false | 0.04289 | 0.038613 | 1.110754 | [
"s593307374",
"s385216829"
] |
u912237403 | p00068 | python | s103941281 | s994927518 | 20 | 10 | 4,280 | 4,276 | Accepted | Accepted | 50 | import sys
def side(p1, p2, p3):
y1,x1=p1
y2,x2=p2
y3,x3=p3
return (x3-x1)*(y2-y1)-(x2-x1)*(y3-y1)>0
while 1:
n=eval(input())
if n==0:break
D=sorted([list(eval(input())) for i in range(n)])
p1=D[0]
D1=D[:]
while True:
for p2 in D1:
if p1==p2:continue
for p3 in D[::-1]:
if p1==p3 or p2==p3: continue
if side(p1,p2,p3)==0:break
else:break
p1=p2
D1.remove(p2)
if p2==D[0]:break
print(len(D1)) | import sys
def side(p1,p2):
global D
y1,x1=p1
y2,x2=p2
dy=y2-y1
dx=x2-x1
for p3 in D[::-1]:
if p1==p3 or p2==p3:continue
y3,x3=p3
if (x3-x1)*dy-dx*(y3-y1)<0:return 0
else:return 1
while 1:
n=eval(input())
if n==0:break
D=sorted([list(eval(input())) for i in range(n)])
p=p1=D[0]
D1=D[:]
while True:
for p2 in D1:
if p1!=p2 and side(p1,p2):break
p1=p2
D1.remove(p2)
if p2==p:break
print(len(D1)) | 23 | 26 | 471 | 469 | import sys
def side(p1, p2, p3):
y1, x1 = p1
y2, x2 = p2
y3, x3 = p3
return (x3 - x1) * (y2 - y1) - (x2 - x1) * (y3 - y1) > 0
while 1:
n = eval(input())
if n == 0:
break
D = sorted([list(eval(input())) for i in range(n)])
p1 = D[0]
D1 = D[:]
while True:
for p2 in D1:
if p1 == p2:
continue
for p3 in D[::-1]:
if p1 == p3 or p2 == p3:
continue
if side(p1, p2, p3) == 0:
break
else:
break
p1 = p2
D1.remove(p2)
if p2 == D[0]:
break
print(len(D1))
| import sys
def side(p1, p2):
global D
y1, x1 = p1
y2, x2 = p2
dy = y2 - y1
dx = x2 - x1
for p3 in D[::-1]:
if p1 == p3 or p2 == p3:
continue
y3, x3 = p3
if (x3 - x1) * dy - dx * (y3 - y1) < 0:
return 0
else:
return 1
while 1:
n = eval(input())
if n == 0:
break
D = sorted([list(eval(input())) for i in range(n)])
p = p1 = D[0]
D1 = D[:]
while True:
for p2 in D1:
if p1 != p2 and side(p1, p2):
break
p1 = p2
D1.remove(p2)
if p2 == p:
break
print(len(D1))
| false | 11.538462 | [
"-def side(p1, p2, p3):",
"+def side(p1, p2):",
"+ global D",
"- y3, x3 = p3",
"- return (x3 - x1) * (y2 - y1) - (x2 - x1) * (y3 - y1) > 0",
"+ dy = y2 - y1",
"+ dx = x2 - x1",
"+ for p3 in D[::-1]:",
"+ if p1 == p3 or p2 == p3:",
"+ continue",
"+ y3, x3 = p3",
"+ if (x3 - x1) * dy - dx * (y3 - y1) < 0:",
"+ return 0",
"+ else:",
"+ return 1",
"- p1 = D[0]",
"+ p = p1 = D[0]",
"- if p1 == p2:",
"- continue",
"- for p3 in D[::-1]:",
"- if p1 == p3 or p2 == p3:",
"- continue",
"- if side(p1, p2, p3) == 0:",
"- break",
"- else:",
"+ if p1 != p2 and side(p1, p2):",
"- if p2 == D[0]:",
"+ if p2 == p:"
] | false | 0.039148 | 0.039302 | 0.996074 | [
"s103941281",
"s994927518"
] |
u211706121 | p02580 | python | s415565043 | s200952120 | 1,003 | 654 | 210,420 | 225,432 | Accepted | Accepted | 34.8 |
from collections import defaultdict
H,W,M=list(map(int,input().split()))
AB=[tuple(map(int,input().split()))for i in range(M)]
AB=[(a-1,b-1)for a,b in AB]
st=set(AB)
Wc=defaultdict(lambda :0)
Hc=defaultdict(lambda :0)
for a,b in AB:
Hc[a]+=1
Wc[b]+=1
Hm=max(Hc.values())
hhh=list(Hc.keys())
www=list(Wc.keys())
for i in hhh:
if Hc[i]!=Hm:
Hc.pop(i)
Wm=max(Wc.values())
for j in www:
if Wc[j]!=Wm:
Wc.pop(j)
ans=0
count=0
for i in list(Hc.keys()):
for j in list(Wc.keys()):
add = -1 if (i,j) in st else 0
tmp= Hc[i] + Wc[j] + add
ans=max(ans,tmp)
if count>300000:
break
count+=1
print(ans)
| H,W,M=list(map(int,input().split()))
HW=[tuple(map(int,input().split()))for i in range(M)]
HW=[(h-1,w-1)for h,w in HW]
st=set(HW)
countH=[0]*H
countW=[0]*W
for h,w in HW:
countH[h]+=1
countW[w]+=1
maxH=max(countH)
maxW=max(countW)
candiH=[]
candiW=[]
for i in range(H):
if maxH==countH[i]:
candiH.append(i)
for i in range(W):
if maxW==countW[i]:
candiW.append(i)
count=0
ans=maxH+maxW-1
add=0
for i in candiH:
for j in candiW:
if (i,j) not in st:
add=1
if count>300000:
break
count+=1
print((ans+add)) | 37 | 30 | 701 | 606 | from collections import defaultdict
H, W, M = list(map(int, input().split()))
AB = [tuple(map(int, input().split())) for i in range(M)]
AB = [(a - 1, b - 1) for a, b in AB]
st = set(AB)
Wc = defaultdict(lambda: 0)
Hc = defaultdict(lambda: 0)
for a, b in AB:
Hc[a] += 1
Wc[b] += 1
Hm = max(Hc.values())
hhh = list(Hc.keys())
www = list(Wc.keys())
for i in hhh:
if Hc[i] != Hm:
Hc.pop(i)
Wm = max(Wc.values())
for j in www:
if Wc[j] != Wm:
Wc.pop(j)
ans = 0
count = 0
for i in list(Hc.keys()):
for j in list(Wc.keys()):
add = -1 if (i, j) in st else 0
tmp = Hc[i] + Wc[j] + add
ans = max(ans, tmp)
if count > 300000:
break
count += 1
print(ans)
| H, W, M = list(map(int, input().split()))
HW = [tuple(map(int, input().split())) for i in range(M)]
HW = [(h - 1, w - 1) for h, w in HW]
st = set(HW)
countH = [0] * H
countW = [0] * W
for h, w in HW:
countH[h] += 1
countW[w] += 1
maxH = max(countH)
maxW = max(countW)
candiH = []
candiW = []
for i in range(H):
if maxH == countH[i]:
candiH.append(i)
for i in range(W):
if maxW == countW[i]:
candiW.append(i)
count = 0
ans = maxH + maxW - 1
add = 0
for i in candiH:
for j in candiW:
if (i, j) not in st:
add = 1
if count > 300000:
break
count += 1
print((ans + add))
| false | 18.918919 | [
"-from collections import defaultdict",
"-",
"-AB = [tuple(map(int, input().split())) for i in range(M)]",
"-AB = [(a - 1, b - 1) for a, b in AB]",
"-st = set(AB)",
"-Wc = defaultdict(lambda: 0)",
"-Hc = defaultdict(lambda: 0)",
"-for a, b in AB:",
"- Hc[a] += 1",
"- Wc[b] += 1",
"-Hm = max(Hc.values())",
"-hhh = list(Hc.keys())",
"-www = list(Wc.keys())",
"-for i in hhh:",
"- if Hc[i] != Hm:",
"- Hc.pop(i)",
"-Wm = max(Wc.values())",
"-for j in www:",
"- if Wc[j] != Wm:",
"- Wc.pop(j)",
"-ans = 0",
"+HW = [tuple(map(int, input().split())) for i in range(M)]",
"+HW = [(h - 1, w - 1) for h, w in HW]",
"+st = set(HW)",
"+countH = [0] * H",
"+countW = [0] * W",
"+for h, w in HW:",
"+ countH[h] += 1",
"+ countW[w] += 1",
"+maxH = max(countH)",
"+maxW = max(countW)",
"+candiH = []",
"+candiW = []",
"+for i in range(H):",
"+ if maxH == countH[i]:",
"+ candiH.append(i)",
"+for i in range(W):",
"+ if maxW == countW[i]:",
"+ candiW.append(i)",
"-for i in list(Hc.keys()):",
"- for j in list(Wc.keys()):",
"- add = -1 if (i, j) in st else 0",
"- tmp = Hc[i] + Wc[j] + add",
"- ans = max(ans, tmp)",
"+ans = maxH + maxW - 1",
"+add = 0",
"+for i in candiH:",
"+ for j in candiW:",
"+ if (i, j) not in st:",
"+ add = 1",
"-print(ans)",
"+print((ans + add))"
] | false | 0.138216 | 0.081781 | 1.69008 | [
"s415565043",
"s200952120"
] |
u901582103 | p02912 | python | s101555955 | s054359437 | 162 | 145 | 14,180 | 14,180 | Accepted | Accepted | 10.49 | from heapq import heappop, heappush
n,m=list(map(int,input().split()))
A=list(map(int,input().split()))
B=sorted([x * -1 for x in A])
for i in range(m):
a=heappop(B)
a=-(-a//2)
heappush(B,a)
print((-sum(B))) | from heapq import heappop,heappush,heapify
n,m=list(map(int,input().split()))
A=[-i for i in list(map(int,input().split()))]
heapify(A)
for i in range(m):
a=heappop(A)
heappush(A,-(-a//2))
print((-sum(A))) | 9 | 8 | 224 | 206 | from heapq import heappop, heappush
n, m = list(map(int, input().split()))
A = list(map(int, input().split()))
B = sorted([x * -1 for x in A])
for i in range(m):
a = heappop(B)
a = -(-a // 2)
heappush(B, a)
print((-sum(B)))
| from heapq import heappop, heappush, heapify
n, m = list(map(int, input().split()))
A = [-i for i in list(map(int, input().split()))]
heapify(A)
for i in range(m):
a = heappop(A)
heappush(A, -(-a // 2))
print((-sum(A)))
| false | 11.111111 | [
"-from heapq import heappop, heappush",
"+from heapq import heappop, heappush, heapify",
"-A = list(map(int, input().split()))",
"-B = sorted([x * -1 for x in A])",
"+A = [-i for i in list(map(int, input().split()))]",
"+heapify(A)",
"- a = heappop(B)",
"- a = -(-a // 2)",
"- heappush(B, a)",
"-print((-sum(B)))",
"+ a = heappop(A)",
"+ heappush(A, -(-a // 2))",
"+print((-sum(A)))"
] | false | 0.085978 | 0.086452 | 0.99451 | [
"s101555955",
"s054359437"
] |
u064505481 | p03165 | python | s843773839 | s452942876 | 628 | 426 | 123,996 | 153,872 | Accepted | Accepted | 32.17 | from sys import stdin, stdout
from collections import deque, defaultdict
import math as m
rl = lambda: stdin.readline()
rll = lambda: stdin.readline().split()
rli = lambda: list(map(int, stdin.readline().split()))
INF, NINF = float('inf'), float('-inf')
def main():
s = rll()[0]
t = rll()[0]
m, n = len(s), len(t)
dp = [[0 for __ in range(n)] for _ in range(m)]
#dp[i][j] = LCs of s0,...,si and t0,...,tj
def pprint(M):
for row in M:
print(row)
print("~~~")
dp[0][0] = 1 if s[0] == t[0] else 0
for c in range(1, n):
dp[0][c] = max(dp[0][c-1], 1 if s[0] == t[c] else 0)
for r in range(1, m):
dp[r][0] = max(dp[r-1][0], 1 if s[r] == t[0] else 0)
for r in range(1, m):
for c in range(1, n):
dp[r][c] = max(dp[r][c], dp[r-1][c], dp[r][c-1])
if s[r] == t[c]:
dp[r][c] = max(dp[r][c], 1 + dp[r-1][c-1])
ans = deque()
i, j = m - 1, n - 1
while i >= 0 and j >= 0:
if s[i] == t[j]:
ans.appendleft(s[i])
i -= 1
j -= 1
else:
up, left = NINF, NINF
if i - 1 >= 0:
up = dp[i-1][j]
if j - 1 >= 0:
left = dp[i][j-1]
if up >= left:
i -= 1
else:
j -= 1
print(("".join(x for x in ans)))
stdout.close()
if __name__ == "__main__":
main() | from sys import stdin, stdout, setrecursionlimit
from collections import deque, defaultdict, Counter
from heapq import heappush, heappop
import math
rl = lambda: stdin.readline()
rll = lambda: stdin.readline().split()
rli = lambda: list(map(int, stdin.readline().split()))
rlf = lambda: list(map(float, stdin.readline().split()))
INF, NINF = float('inf'), float('-inf')
def main():
s, t = rll()[0], rll()[0]
m, n = len(s), len(t)
dp = [[0 for __ in range(n)] for _ in range(m)]
dp[0][0] = 1 if s[0] == t[0] else 0
for r in range(1, m):
dp[r][0] = max(dp[r-1][0], 1 if s[r] == t[0] else 0)
for c in range(1, n):
dp[0][c] = max(dp[0][c-1], 1 if s[0] == t[c] else 0)
for r in range(1, m):
for c in range(1, n):
dp[r][c] = max(dp[r-1][c], dp[r][c-1])
if s[r] == t[c]:
dp[r][c] = max(dp[r][c], 1 + dp[r-1][c-1])
ans = deque()
r, c = m-1, n-1
while r >= 0 and c >= 0:
if s[r] == t[c]:
ans.appendleft(s[r])
r -= 1
c -= 1
else:
U = dp[r-1][c] if r > 0 else NINF
L = dp[r][c-1] if c > 0 else NINF
if L >= U:
c -= 1
else:
r -= 1
print(("".join(x for x in ans)))
stdout.close()
if __name__ == "__main__":
main() | 57 | 45 | 1,257 | 1,196 | from sys import stdin, stdout
from collections import deque, defaultdict
import math as m
rl = lambda: stdin.readline()
rll = lambda: stdin.readline().split()
rli = lambda: list(map(int, stdin.readline().split()))
INF, NINF = float("inf"), float("-inf")
def main():
s = rll()[0]
t = rll()[0]
m, n = len(s), len(t)
dp = [[0 for __ in range(n)] for _ in range(m)]
# dp[i][j] = LCs of s0,...,si and t0,...,tj
def pprint(M):
for row in M:
print(row)
print("~~~")
dp[0][0] = 1 if s[0] == t[0] else 0
for c in range(1, n):
dp[0][c] = max(dp[0][c - 1], 1 if s[0] == t[c] else 0)
for r in range(1, m):
dp[r][0] = max(dp[r - 1][0], 1 if s[r] == t[0] else 0)
for r in range(1, m):
for c in range(1, n):
dp[r][c] = max(dp[r][c], dp[r - 1][c], dp[r][c - 1])
if s[r] == t[c]:
dp[r][c] = max(dp[r][c], 1 + dp[r - 1][c - 1])
ans = deque()
i, j = m - 1, n - 1
while i >= 0 and j >= 0:
if s[i] == t[j]:
ans.appendleft(s[i])
i -= 1
j -= 1
else:
up, left = NINF, NINF
if i - 1 >= 0:
up = dp[i - 1][j]
if j - 1 >= 0:
left = dp[i][j - 1]
if up >= left:
i -= 1
else:
j -= 1
print(("".join(x for x in ans)))
stdout.close()
if __name__ == "__main__":
main()
| from sys import stdin, stdout, setrecursionlimit
from collections import deque, defaultdict, Counter
from heapq import heappush, heappop
import math
rl = lambda: stdin.readline()
rll = lambda: stdin.readline().split()
rli = lambda: list(map(int, stdin.readline().split()))
rlf = lambda: list(map(float, stdin.readline().split()))
INF, NINF = float("inf"), float("-inf")
def main():
s, t = rll()[0], rll()[0]
m, n = len(s), len(t)
dp = [[0 for __ in range(n)] for _ in range(m)]
dp[0][0] = 1 if s[0] == t[0] else 0
for r in range(1, m):
dp[r][0] = max(dp[r - 1][0], 1 if s[r] == t[0] else 0)
for c in range(1, n):
dp[0][c] = max(dp[0][c - 1], 1 if s[0] == t[c] else 0)
for r in range(1, m):
for c in range(1, n):
dp[r][c] = max(dp[r - 1][c], dp[r][c - 1])
if s[r] == t[c]:
dp[r][c] = max(dp[r][c], 1 + dp[r - 1][c - 1])
ans = deque()
r, c = m - 1, n - 1
while r >= 0 and c >= 0:
if s[r] == t[c]:
ans.appendleft(s[r])
r -= 1
c -= 1
else:
U = dp[r - 1][c] if r > 0 else NINF
L = dp[r][c - 1] if c > 0 else NINF
if L >= U:
c -= 1
else:
r -= 1
print(("".join(x for x in ans)))
stdout.close()
if __name__ == "__main__":
main()
| false | 21.052632 | [
"-from sys import stdin, stdout",
"-from collections import deque, defaultdict",
"-import math as m",
"+from sys import stdin, stdout, setrecursionlimit",
"+from collections import deque, defaultdict, Counter",
"+from heapq import heappush, heappop",
"+import math",
"+rlf = lambda: list(map(float, stdin.readline().split()))",
"- s = rll()[0]",
"- t = rll()[0]",
"+ s, t = rll()[0], rll()[0]",
"- # dp[i][j] = LCs of s0,...,si and t0,...,tj",
"- def pprint(M):",
"- for row in M:",
"- print(row)",
"- print(\"~~~\")",
"-",
"+ for r in range(1, m):",
"+ dp[r][0] = max(dp[r - 1][0], 1 if s[r] == t[0] else 0)",
"- dp[r][0] = max(dp[r - 1][0], 1 if s[r] == t[0] else 0)",
"- for r in range(1, m):",
"- dp[r][c] = max(dp[r][c], dp[r - 1][c], dp[r][c - 1])",
"+ dp[r][c] = max(dp[r - 1][c], dp[r][c - 1])",
"- i, j = m - 1, n - 1",
"- while i >= 0 and j >= 0:",
"- if s[i] == t[j]:",
"- ans.appendleft(s[i])",
"- i -= 1",
"- j -= 1",
"+ r, c = m - 1, n - 1",
"+ while r >= 0 and c >= 0:",
"+ if s[r] == t[c]:",
"+ ans.appendleft(s[r])",
"+ r -= 1",
"+ c -= 1",
"- up, left = NINF, NINF",
"- if i - 1 >= 0:",
"- up = dp[i - 1][j]",
"- if j - 1 >= 0:",
"- left = dp[i][j - 1]",
"- if up >= left:",
"- i -= 1",
"+ U = dp[r - 1][c] if r > 0 else NINF",
"+ L = dp[r][c - 1] if c > 0 else NINF",
"+ if L >= U:",
"+ c -= 1",
"- j -= 1",
"+ r -= 1"
] | false | 0.110277 | 0.0467 | 2.3614 | [
"s843773839",
"s452942876"
] |
u119982001 | p03681 | python | s365824356 | s804033139 | 711 | 64 | 5,180 | 3,060 | Accepted | Accepted | 91 | from math import factorial as frac
N, M = list(map(int, input().split()))
INF = 10**9 + 7
if abs(N-M) > 1:
print((0))
elif abs(N-M) == 1:
print((frac(N)*frac(M)%INF))
else:
print((((frac(N)*frac(M))*2)%INF))
| from math import factorial as frac
N, M = list(map(int, input().split()))
MOD = 10**9 + 7
def nPk(n, k):
r = 1
while k > 0:
r *= n
r %= MOD
n -= 1
k -= 1
return r
if abs(N-M) > 1:
print((0))
elif N==M:
print((((nPk(N,N)*nPk(M,M))*2)%MOD))
else:
print((nPk(N,N)*nPk(M,M)%MOD))
| 12 | 21 | 222 | 345 | from math import factorial as frac
N, M = list(map(int, input().split()))
INF = 10**9 + 7
if abs(N - M) > 1:
print((0))
elif abs(N - M) == 1:
print((frac(N) * frac(M) % INF))
else:
print((((frac(N) * frac(M)) * 2) % INF))
| from math import factorial as frac
N, M = list(map(int, input().split()))
MOD = 10**9 + 7
def nPk(n, k):
r = 1
while k > 0:
r *= n
r %= MOD
n -= 1
k -= 1
return r
if abs(N - M) > 1:
print((0))
elif N == M:
print((((nPk(N, N) * nPk(M, M)) * 2) % MOD))
else:
print((nPk(N, N) * nPk(M, M) % MOD))
| false | 42.857143 | [
"-INF = 10**9 + 7",
"+MOD = 10**9 + 7",
"+",
"+",
"+def nPk(n, k):",
"+ r = 1",
"+ while k > 0:",
"+ r *= n",
"+ r %= MOD",
"+ n -= 1",
"+ k -= 1",
"+ return r",
"+",
"+",
"-elif abs(N - M) == 1:",
"- print((frac(N) * frac(M) % INF))",
"+elif N == M:",
"+ print((((nPk(N, N) * nPk(M, M)) * 2) % MOD))",
"- print((((frac(N) * frac(M)) * 2) % INF))",
"+ print((nPk(N, N) * nPk(M, M) % MOD))"
] | false | 0.042638 | 0.038583 | 1.105108 | [
"s365824356",
"s804033139"
] |
u020373088 | p03416 | python | s510622669 | s710017761 | 61 | 18 | 2,940 | 3,060 | Accepted | Accepted | 70.49 | a, b = list(map(int, input().split()))
ans = 0
for i in range(a,b+1):
if str(i) == str(i)[::-1]:
ans += 1
print(ans) | a, b = list(map(int, input().split()))
ans = 0
for i in range(1,10):
for j in range(0,10):
for k in range(0,10):
x = 10000*i + 1000*j + 100*k + 10*j + i
if a <= x <= b:
ans += 1
print(ans) | 6 | 9 | 121 | 216 | a, b = list(map(int, input().split()))
ans = 0
for i in range(a, b + 1):
if str(i) == str(i)[::-1]:
ans += 1
print(ans)
| a, b = list(map(int, input().split()))
ans = 0
for i in range(1, 10):
for j in range(0, 10):
for k in range(0, 10):
x = 10000 * i + 1000 * j + 100 * k + 10 * j + i
if a <= x <= b:
ans += 1
print(ans)
| false | 33.333333 | [
"-for i in range(a, b + 1):",
"- if str(i) == str(i)[::-1]:",
"- ans += 1",
"+for i in range(1, 10):",
"+ for j in range(0, 10):",
"+ for k in range(0, 10):",
"+ x = 10000 * i + 1000 * j + 100 * k + 10 * j + i",
"+ if a <= x <= b:",
"+ ans += 1"
] | false | 0.059931 | 0.073096 | 0.819901 | [
"s510622669",
"s710017761"
] |
u131625544 | p02983 | python | s579769495 | s040057190 | 1,508 | 205 | 3,064 | 39,024 | Accepted | Accepted | 86.41 | L, R = (int(i) for i in input().split())
if (R - L) <= 2019:
temp1 = float("inf")
for i in range(R - L):
for j in range(R - L):
temp2 = ((R-i) * (R - 1 -j)) % 2019
if temp2 < temp1:
temp1 = temp2
print(temp1)
else:
temp1 = float("inf")
for i in range(2019):
if (R-i-1) < L:
break
for j in range(2019):
temp2 = ((R - i) * (R - 1 - j)) % 2019
if temp2 < temp1:
temp1 = temp2
print(temp1) | import sys
input = sys.stdin.readline
class Solution:
def main(self):
L, R = list(map(int, input().split()))
ans = 2019
for i in range(L, min(R + 1, L + 2019)):
for j in range(i + 1, min(R + 1, L + 2019)):
ans = min(ans, (i * j) % 2019)
print(ans)
# Run main
if __name__ == '__main__':
Solution().main()
| 20 | 20 | 545 | 392 | L, R = (int(i) for i in input().split())
if (R - L) <= 2019:
temp1 = float("inf")
for i in range(R - L):
for j in range(R - L):
temp2 = ((R - i) * (R - 1 - j)) % 2019
if temp2 < temp1:
temp1 = temp2
print(temp1)
else:
temp1 = float("inf")
for i in range(2019):
if (R - i - 1) < L:
break
for j in range(2019):
temp2 = ((R - i) * (R - 1 - j)) % 2019
if temp2 < temp1:
temp1 = temp2
print(temp1)
| import sys
input = sys.stdin.readline
class Solution:
def main(self):
L, R = list(map(int, input().split()))
ans = 2019
for i in range(L, min(R + 1, L + 2019)):
for j in range(i + 1, min(R + 1, L + 2019)):
ans = min(ans, (i * j) % 2019)
print(ans)
# Run main
if __name__ == "__main__":
Solution().main()
| false | 0 | [
"-L, R = (int(i) for i in input().split())",
"-if (R - L) <= 2019:",
"- temp1 = float(\"inf\")",
"- for i in range(R - L):",
"- for j in range(R - L):",
"- temp2 = ((R - i) * (R - 1 - j)) % 2019",
"- if temp2 < temp1:",
"- temp1 = temp2",
"- print(temp1)",
"-else:",
"- temp1 = float(\"inf\")",
"- for i in range(2019):",
"- if (R - i - 1) < L:",
"- break",
"- for j in range(2019):",
"- temp2 = ((R - i) * (R - 1 - j)) % 2019",
"- if temp2 < temp1:",
"- temp1 = temp2",
"- print(temp1)",
"+import sys",
"+",
"+input = sys.stdin.readline",
"+",
"+",
"+class Solution:",
"+ def main(self):",
"+ L, R = list(map(int, input().split()))",
"+ ans = 2019",
"+ for i in range(L, min(R + 1, L + 2019)):",
"+ for j in range(i + 1, min(R + 1, L + 2019)):",
"+ ans = min(ans, (i * j) % 2019)",
"+ print(ans)",
"+",
"+",
"+# Run main",
"+if __name__ == \"__main__\":",
"+ Solution().main()"
] | false | 0.199857 | 0.007308 | 27.346421 | [
"s579769495",
"s040057190"
] |
u604774382 | p02382 | python | s492115957 | s488661927 | 40 | 20 | 6,868 | 5,720 | Accepted | Accepted | 50 | import math
def getDistance( x, y, n, p ):
dxy = 0
for i in range( n ):
dxy += abs( x[i] - y[i] )**p
return dxy**(1/float( p ) )
n = int( eval(input()) )
x = [ float( i ) for i in input( ).split( " " ) ]
y = [ float( i ) for i in input( ).split( " " ) ]
print(( getDistance( x, y, n, 1 ) ))
print(( getDistance( x, y, n, 2 ) ))
print(( getDistance( x, y, n, 3 ) ))
dxy = [ 0 ]*(n+1)
for i in range( n ):
dxy[i] = abs( x[i] - y[i] )
print(( max( dxy ) )) | import math
n = int( eval(input()) )
x = [ float( val ) for val in input().split( ' ' ) ]
y = [ float( val ) for val in input().split( ' ' ) ]
Dxy = Dxy2 = Dxy3 = Dxyp = 0
for i in range( n ):
t = abs(x[i]-y[i])
Dxy += t
Dxy2 += t**2
Dxy3 += t**3
Dxyp = max( Dxyp, t )
print( Dxy )
print(( Dxy2**(1/2) ))
print(( Dxy3**(1/3) ))
print( Dxyp )
| 20 | 18 | 468 | 357 | import math
def getDistance(x, y, n, p):
dxy = 0
for i in range(n):
dxy += abs(x[i] - y[i]) ** p
return dxy ** (1 / float(p))
n = int(eval(input()))
x = [float(i) for i in input().split(" ")]
y = [float(i) for i in input().split(" ")]
print((getDistance(x, y, n, 1)))
print((getDistance(x, y, n, 2)))
print((getDistance(x, y, n, 3)))
dxy = [0] * (n + 1)
for i in range(n):
dxy[i] = abs(x[i] - y[i])
print((max(dxy)))
| import math
n = int(eval(input()))
x = [float(val) for val in input().split(" ")]
y = [float(val) for val in input().split(" ")]
Dxy = Dxy2 = Dxy3 = Dxyp = 0
for i in range(n):
t = abs(x[i] - y[i])
Dxy += t
Dxy2 += t**2
Dxy3 += t**3
Dxyp = max(Dxyp, t)
print(Dxy)
print((Dxy2 ** (1 / 2)))
print((Dxy3 ** (1 / 3)))
print(Dxyp)
| false | 10 | [
"-",
"-def getDistance(x, y, n, p):",
"- dxy = 0",
"- for i in range(n):",
"- dxy += abs(x[i] - y[i]) ** p",
"- return dxy ** (1 / float(p))",
"-",
"-",
"-x = [float(i) for i in input().split(\" \")]",
"-y = [float(i) for i in input().split(\" \")]",
"-print((getDistance(x, y, n, 1)))",
"-print((getDistance(x, y, n, 2)))",
"-print((getDistance(x, y, n, 3)))",
"-dxy = [0] * (n + 1)",
"+x = [float(val) for val in input().split(\" \")]",
"+y = [float(val) for val in input().split(\" \")]",
"+Dxy = Dxy2 = Dxy3 = Dxyp = 0",
"- dxy[i] = abs(x[i] - y[i])",
"-print((max(dxy)))",
"+ t = abs(x[i] - y[i])",
"+ Dxy += t",
"+ Dxy2 += t**2",
"+ Dxy3 += t**3",
"+ Dxyp = max(Dxyp, t)",
"+print(Dxy)",
"+print((Dxy2 ** (1 / 2)))",
"+print((Dxy3 ** (1 / 3)))",
"+print(Dxyp)"
] | false | 0.117339 | 0.048491 | 2.419831 | [
"s492115957",
"s488661927"
] |
u844789719 | p03725 | python | s401399920 | s080558292 | 674 | 616 | 107,228 | 101,212 | Accepted | Accepted | 8.61 | import itertools, math, collections, sys
input = sys.stdin.readline
H, W, K = [int(_) for _ in input().split()]
A = [list(eval(input())) for _ in range(H)]
for h, w in itertools.product(list(range(H)), list(range(W))):
if A[h][w] == 'S':
break
visited = [['.'] * W for _ in range(H)]
res = K - 1
Q = collections.deque([[h - 1, w, res], [h + 1, w, res], [h, w - 1, res],
[h, w + 1, res]])
sH = set([h])
sW = set([w])
while Q:
h, w, res = Q.popleft()
if 0 <= h < H and 0 <= w < W and A[h][w] == '.' and visited[h][w] != '#':
visited[h][w] = '#'
sH.add(h)
sW.add(w)
if res:
res -= 1
Q += [[h - 1, w, res], [h + 1, w, res], [h, w - 1, res],
[h, w + 1, res]]
print((1 +
math.ceil(min([min(sH), H - 1 - max(sH),
min(sW), W - 1 - max(sW)]) / K)))
| import itertools, math, collections, sys
input = sys.stdin.readline
H, W, K = [int(_) for _ in input().split()]
A = [list(eval(input())) for _ in range(H)]
for h, w in itertools.product(list(range(H)), list(range(W))):
if A[h][w] == 'S':
break
visited = A
res = K - 1
Q = collections.deque([[h - 1, w, res], [h + 1, w, res], [h, w - 1, res],
[h, w + 1, res]])
sH = set([h])
sW = set([w])
while Q:
h, w, res = Q.popleft()
if 0 <= h < H and 0 <= w < W and A[h][w] == '.' and visited[h][w] != '#':
visited[h][w] = '#'
sH.add(h)
sW.add(w)
if res:
res -= 1
Q += [[h - 1, w, res], [h + 1, w, res], [h, w - 1, res],
[h, w + 1, res]]
print((1 +
math.ceil(min([min(sH), H - 1 - max(sH),
min(sW), W - 1 - max(sW)]) / K)))
| 26 | 26 | 889 | 861 | import itertools, math, collections, sys
input = sys.stdin.readline
H, W, K = [int(_) for _ in input().split()]
A = [list(eval(input())) for _ in range(H)]
for h, w in itertools.product(list(range(H)), list(range(W))):
if A[h][w] == "S":
break
visited = [["."] * W for _ in range(H)]
res = K - 1
Q = collections.deque(
[[h - 1, w, res], [h + 1, w, res], [h, w - 1, res], [h, w + 1, res]]
)
sH = set([h])
sW = set([w])
while Q:
h, w, res = Q.popleft()
if 0 <= h < H and 0 <= w < W and A[h][w] == "." and visited[h][w] != "#":
visited[h][w] = "#"
sH.add(h)
sW.add(w)
if res:
res -= 1
Q += [[h - 1, w, res], [h + 1, w, res], [h, w - 1, res], [h, w + 1, res]]
print((1 + math.ceil(min([min(sH), H - 1 - max(sH), min(sW), W - 1 - max(sW)]) / K)))
| import itertools, math, collections, sys
input = sys.stdin.readline
H, W, K = [int(_) for _ in input().split()]
A = [list(eval(input())) for _ in range(H)]
for h, w in itertools.product(list(range(H)), list(range(W))):
if A[h][w] == "S":
break
visited = A
res = K - 1
Q = collections.deque(
[[h - 1, w, res], [h + 1, w, res], [h, w - 1, res], [h, w + 1, res]]
)
sH = set([h])
sW = set([w])
while Q:
h, w, res = Q.popleft()
if 0 <= h < H and 0 <= w < W and A[h][w] == "." and visited[h][w] != "#":
visited[h][w] = "#"
sH.add(h)
sW.add(w)
if res:
res -= 1
Q += [[h - 1, w, res], [h + 1, w, res], [h, w - 1, res], [h, w + 1, res]]
print((1 + math.ceil(min([min(sH), H - 1 - max(sH), min(sW), W - 1 - max(sW)]) / K)))
| false | 0 | [
"-visited = [[\".\"] * W for _ in range(H)]",
"+visited = A"
] | false | 0.117677 | 0.11672 | 1.008194 | [
"s401399920",
"s080558292"
] |
u952708174 | p03634 | python | s829625972 | s099028759 | 1,270 | 1,119 | 89,924 | 88,688 | Accepted | Accepted | 11.89 | def Q4(x):
N = x[0][0] # 木の頂点数
edge = x[1:N][:] # 辺とその距離
Q = x[N][0] # クエリ数
K = x[N][1] # 経由すべき頂点の番号
query = x[N + 1:][:] # クエリの内容
# 木の初期化
tree = list(range(N)) # adjacent(隣接)のほうがいいかな？
for idx in range(N):
tree[idx] = []
for idx in range(len(edge)):
# i番目の要素は、節点iに接続されている節点
# これ以降、-1を足すのは、頂点の添字が1スタートに対しリストは0スタートのため
a = edge[idx][0] - 1
b = edge[idx][1] - 1
c = edge[idx][2]
tree[a].append([b, c])
tree[b].append([a, c])
# Kから各節点への距離を求める
dist = [0 for i in range(N)] # 頂点Kからの距離
isVisit = [False for i in range(N)] # ある頂点が探索済か
queue = [K - 1] #幅探索用キュー
isVisit[K - 1] = True
while queue:
u = queue.pop()
for p in tree[u]:
v, w = list(map(int, p))
if not isVisit[v]:
isVisit[v] = True
dist[v] = dist[u] + w
queue.append(v)
for q in query:
print((dist[q[0] - 1] + dist[q[1] - 1]))
N=int(eval(input()))
edge = [[int(i) for i in input().split()] for i in range(N-1)]
Q , K = (int(i) for i in input().split())
query = [[int(i) for i in input().split()] for i in range(Q)]
l = [[N]]+edge+[[Q,K]]+query
Q4(l) | def d_transit_tree_path(N, E, Q, K, V):
# 頂点数、辺とそのコスト、クエリの数、経由する頂点、出発/到達頂点
# 隣接リストの作成
edge = [[] for _ in range(N)]
for a, b, c in E:
edge[a - 1].append([b - 1, c])
edge[b - 1].append([a - 1, c])
# Kから各節点への距離を求める
dist = [0 for i in range(N)] # 頂点Kからの距離
is_visit = [False for i in range(N)] # ある頂点が探索済か
is_visit[K - 1] = True # 頂点Kは探索済とする
queue = [K - 1] # 幅探索用キュー
while queue:
u = queue.pop()
for v, c in edge[u]:
if not is_visit[v]:
is_visit[v] = True
dist[v] = dist[u] + c
queue.append(v)
ans = ''
for q1, q2 in V:
ans += '{}\n'.format(dist[q1 - 1] + dist[q2 - 1])
ans = ans[:-1]
return ans
N = int(eval(input()))
E = [[int(i) for i in input().split()] for j in range(N-1)]
Q,K = [int(i) for i in input().split()]
V = [[int(i) for i in input().split()] for j in range(Q)]
print((d_transit_tree_path(N, E, Q, K, V))) | 45 | 34 | 1,275 | 1,007 | def Q4(x):
N = x[0][0] # 木の頂点数
edge = x[1:N][:] # 辺とその距離
Q = x[N][0] # クエリ数
K = x[N][1] # 経由すべき頂点の番号
query = x[N + 1 :][:] # クエリの内容
# 木の初期化
tree = list(range(N)) # adjacent(隣接)のほうがいいかな？
for idx in range(N):
tree[idx] = []
for idx in range(len(edge)):
# i番目の要素は、節点iに接続されている節点
# これ以降、-1を足すのは、頂点の添字が1スタートに対しリストは0スタートのため
a = edge[idx][0] - 1
b = edge[idx][1] - 1
c = edge[idx][2]
tree[a].append([b, c])
tree[b].append([a, c])
# Kから各節点への距離を求める
dist = [0 for i in range(N)] # 頂点Kからの距離
isVisit = [False for i in range(N)] # ある頂点が探索済か
queue = [K - 1] # 幅探索用キュー
isVisit[K - 1] = True
while queue:
u = queue.pop()
for p in tree[u]:
v, w = list(map(int, p))
if not isVisit[v]:
isVisit[v] = True
dist[v] = dist[u] + w
queue.append(v)
for q in query:
print((dist[q[0] - 1] + dist[q[1] - 1]))
N = int(eval(input()))
edge = [[int(i) for i in input().split()] for i in range(N - 1)]
Q, K = (int(i) for i in input().split())
query = [[int(i) for i in input().split()] for i in range(Q)]
l = [[N]] + edge + [[Q, K]] + query
Q4(l)
| def d_transit_tree_path(N, E, Q, K, V):
# 頂点数、辺とそのコスト、クエリの数、経由する頂点、出発/到達頂点
# 隣接リストの作成
edge = [[] for _ in range(N)]
for a, b, c in E:
edge[a - 1].append([b - 1, c])
edge[b - 1].append([a - 1, c])
# Kから各節点への距離を求める
dist = [0 for i in range(N)] # 頂点Kからの距離
is_visit = [False for i in range(N)] # ある頂点が探索済か
is_visit[K - 1] = True # 頂点Kは探索済とする
queue = [K - 1] # 幅探索用キュー
while queue:
u = queue.pop()
for v, c in edge[u]:
if not is_visit[v]:
is_visit[v] = True
dist[v] = dist[u] + c
queue.append(v)
ans = ""
for q1, q2 in V:
ans += "{}\n".format(dist[q1 - 1] + dist[q2 - 1])
ans = ans[:-1]
return ans
N = int(eval(input()))
E = [[int(i) for i in input().split()] for j in range(N - 1)]
Q, K = [int(i) for i in input().split()]
V = [[int(i) for i in input().split()] for j in range(Q)]
print((d_transit_tree_path(N, E, Q, K, V)))
| false | 24.444444 | [
"-def Q4(x):",
"- N = x[0][0] # 木の頂点数",
"- edge = x[1:N][:] # 辺とその距離",
"- Q = x[N][0] # クエリ数",
"- K = x[N][1] # 経由すべき頂点の番号",
"- query = x[N + 1 :][:] # クエリの内容",
"- # 木の初期化",
"- tree = list(range(N)) # adjacent(隣接)のほうがいいかな？",
"- for idx in range(N):",
"- tree[idx] = []",
"- for idx in range(len(edge)):",
"- # i番目の要素は、節点iに接続されている節点",
"- # これ以降、-1を足すのは、頂点の添字が1スタートに対しリストは0スタートのため",
"- a = edge[idx][0] - 1",
"- b = edge[idx][1] - 1",
"- c = edge[idx][2]",
"- tree[a].append([b, c])",
"- tree[b].append([a, c])",
"+def d_transit_tree_path(N, E, Q, K, V):",
"+ # 頂点数、辺とそのコスト、クエリの数、経由する頂点、出発/到達頂点",
"+ # 隣接リストの作成",
"+ edge = [[] for _ in range(N)]",
"+ for a, b, c in E:",
"+ edge[a - 1].append([b - 1, c])",
"+ edge[b - 1].append([a - 1, c])",
"- isVisit = [False for i in range(N)] # ある頂点が探索済か",
"+ is_visit = [False for i in range(N)] # ある頂点が探索済か",
"+ is_visit[K - 1] = True # 頂点Kは探索済とする",
"- isVisit[K - 1] = True",
"- for p in tree[u]:",
"- v, w = list(map(int, p))",
"- if not isVisit[v]:",
"- isVisit[v] = True",
"- dist[v] = dist[u] + w",
"+ for v, c in edge[u]:",
"+ if not is_visit[v]:",
"+ is_visit[v] = True",
"+ dist[v] = dist[u] + c",
"- for q in query:",
"- print((dist[q[0] - 1] + dist[q[1] - 1]))",
"+ ans = \"\"",
"+ for q1, q2 in V:",
"+ ans += \"{}\\n\".format(dist[q1 - 1] + dist[q2 - 1])",
"+ ans = ans[:-1]",
"+ return ans",
"-edge = [[int(i) for i in input().split()] for i in range(N - 1)]",
"-Q, K = (int(i) for i in input().split())",
"-query = [[int(i) for i in input().split()] for i in range(Q)]",
"-l = [[N]] + edge + [[Q, K]] + query",
"-Q4(l)",
"+E = [[int(i) for i in input().split()] for j in range(N - 1)]",
"+Q, K = [int(i) for i in input().split()]",
"+V = [[int(i) for i in input().split()] for j in range(Q)]",
"+print((d_transit_tree_path(N, E, Q, K, V)))"
] | false | 0.041596 | 0.043331 | 0.959958 | [
"s829625972",
"s099028759"
] |
u186838327 | p02972 | python | s794729178 | s762989573 | 881 | 337 | 19,004 | 66,780 | Accepted | Accepted | 61.75 | n = int(eval(input()))
l = list(map(int, input().split()))
ans = [0]*n
for i in reversed(list(range(n))):
j = i+1
b = 0
while j <= n:
b += ans[j-1]
j += i+1
if b%2 != l[i]:
ans[i] = 1
print((sum(ans)))
print((' '.join(map(str, [i+1 for i, x in enumerate(ans) if x!= 0])))) | n = int(eval(input()))
A = list(map(int, input().split()))
B = [0]*n
for i in reversed(list(range(n))):
j = i+1
cnt = 0
while j <= n:
cnt += B[j-1]
j += i+1
if cnt%2 != A[i]:
B[i] = 1
m = 0
ans = []
for i, b in enumerate(B):
if b != 0:
m += 1
ans.append(i+1)
print(m)
if len(ans) > 0:
print((*ans)) | 16 | 23 | 294 | 373 | n = int(eval(input()))
l = list(map(int, input().split()))
ans = [0] * n
for i in reversed(list(range(n))):
j = i + 1
b = 0
while j <= n:
b += ans[j - 1]
j += i + 1
if b % 2 != l[i]:
ans[i] = 1
print((sum(ans)))
print((" ".join(map(str, [i + 1 for i, x in enumerate(ans) if x != 0]))))
| n = int(eval(input()))
A = list(map(int, input().split()))
B = [0] * n
for i in reversed(list(range(n))):
j = i + 1
cnt = 0
while j <= n:
cnt += B[j - 1]
j += i + 1
if cnt % 2 != A[i]:
B[i] = 1
m = 0
ans = []
for i, b in enumerate(B):
if b != 0:
m += 1
ans.append(i + 1)
print(m)
if len(ans) > 0:
print((*ans))
| false | 30.434783 | [
"-l = list(map(int, input().split()))",
"-ans = [0] * n",
"+A = list(map(int, input().split()))",
"+B = [0] * n",
"- b = 0",
"+ cnt = 0",
"- b += ans[j - 1]",
"+ cnt += B[j - 1]",
"- if b % 2 != l[i]:",
"- ans[i] = 1",
"-print((sum(ans)))",
"-print((\" \".join(map(str, [i + 1 for i, x in enumerate(ans) if x != 0]))))",
"+ if cnt % 2 != A[i]:",
"+ B[i] = 1",
"+m = 0",
"+ans = []",
"+for i, b in enumerate(B):",
"+ if b != 0:",
"+ m += 1",
"+ ans.append(i + 1)",
"+print(m)",
"+if len(ans) > 0:",
"+ print((*ans))"
] | false | 0.038052 | 0.045825 | 0.830391 | [
"s794729178",
"s762989573"
] |
u595289165 | p03044 | python | s547690167 | s964491031 | 681 | 402 | 50,852 | 111,416 | Accepted | Accepted | 40.97 | from collections import deque
n = int(eval(input()))
tree = [[] for _ in range(n+1)]
color1 = [-1] * (n+1)
color1[1] = 0
color2 = [-1] * (n+1)
color2[1] = 1
for _ in range(n-1):
u, v, w = list(map(int, input().split()))
tree[u].append((v, w))
tree[v].append((u, w))
q = deque([1])
visited = {1}
while len(q) > 0:
now = q.popleft()
visited.add(now)
for v, w in tree[now]:
if v in visited:
pass
else:
q.append(v)
if w % 2 == 0:
color1[v] = color1[now]
color2[v] = color2[now]
else:
color1[v] = int(not color1[now])
color2[v] = int(not color2[now])
print(("\n".join(tuple(map(str, color1[1:])))))
| n = int(eval(input()))
tree = [[] for _ in range(n+1)]
for _ in range(n-1):
u, v, w = list(map(int, input().split()))
tree[u].append([v, w])
tree[v].append([u, w])
color = [-1] * (n+1)
color[1] = 0
stack = [1]
while stack:
node = stack.pop()
for vertex, weight in tree[node]:
if color[vertex] != -1:
continue
color[vertex] = (color[node] + weight) % 2
stack.append(vertex)
print(("\n".join(map(str, color[1:]))))
| 36 | 25 | 775 | 487 | from collections import deque
n = int(eval(input()))
tree = [[] for _ in range(n + 1)]
color1 = [-1] * (n + 1)
color1[1] = 0
color2 = [-1] * (n + 1)
color2[1] = 1
for _ in range(n - 1):
u, v, w = list(map(int, input().split()))
tree[u].append((v, w))
tree[v].append((u, w))
q = deque([1])
visited = {1}
while len(q) > 0:
now = q.popleft()
visited.add(now)
for v, w in tree[now]:
if v in visited:
pass
else:
q.append(v)
if w % 2 == 0:
color1[v] = color1[now]
color2[v] = color2[now]
else:
color1[v] = int(not color1[now])
color2[v] = int(not color2[now])
print(("\n".join(tuple(map(str, color1[1:])))))
| n = int(eval(input()))
tree = [[] for _ in range(n + 1)]
for _ in range(n - 1):
u, v, w = list(map(int, input().split()))
tree[u].append([v, w])
tree[v].append([u, w])
color = [-1] * (n + 1)
color[1] = 0
stack = [1]
while stack:
node = stack.pop()
for vertex, weight in tree[node]:
if color[vertex] != -1:
continue
color[vertex] = (color[node] + weight) % 2
stack.append(vertex)
print(("\n".join(map(str, color[1:]))))
| false | 30.555556 | [
"-from collections import deque",
"-",
"-color1 = [-1] * (n + 1)",
"-color1[1] = 0",
"-color2 = [-1] * (n + 1)",
"-color2[1] = 1",
"- tree[u].append((v, w))",
"- tree[v].append((u, w))",
"-q = deque([1])",
"-visited = {1}",
"-while len(q) > 0:",
"- now = q.popleft()",
"- visited.add(now)",
"- for v, w in tree[now]:",
"- if v in visited:",
"- pass",
"- else:",
"- q.append(v)",
"- if w % 2 == 0:",
"- color1[v] = color1[now]",
"- color2[v] = color2[now]",
"- else:",
"- color1[v] = int(not color1[now])",
"- color2[v] = int(not color2[now])",
"-print((\"\\n\".join(tuple(map(str, color1[1:])))))",
"+ tree[u].append([v, w])",
"+ tree[v].append([u, w])",
"+color = [-1] * (n + 1)",
"+color[1] = 0",
"+stack = [1]",
"+while stack:",
"+ node = stack.pop()",
"+ for vertex, weight in tree[node]:",
"+ if color[vertex] != -1:",
"+ continue",
"+ color[vertex] = (color[node] + weight) % 2",
"+ stack.append(vertex)",
"+print((\"\\n\".join(map(str, color[1:]))))"
] | false | 0.099592 | 0.110952 | 0.897617 | [
"s547690167",
"s964491031"
] |
u210827208 | p03426 | python | s380332994 | s076806757 | 1,234 | 957 | 45,992 | 20,712 | Accepted | Accepted | 22.45 | H,W,D=list(map(int,input().split()))
A=[list(map(int,input().split())) for _ in range(H)]
Q=int(eval(input()))
X=[[[0,0] for _ in range((H*W)//D+1)] for _ in range(D)]
for i in range(H):
for j in range(W):
X[A[i][j]%D][A[i][j]//D][0]=i
X[A[i][j]%D][A[i][j]//D][1]=j
M=[[0]*((H*W)//D+1) for _ in range(D)]
for d in range(D):
for k in range((H*W)//D):
M[d][k+1]=abs(X[d][k+1][0]-X[d][k][0])+abs(X[d][k+1][1]-X[d][k][1])+M[d][k]
for i in range(Q):
L,R=list(map(int,input().split()))
print((M[L%D][R//D]-M[L%D][L//D])) | H,W,D=list(map(int,input().split()))
A=[list(map(int,input().split())) for _ in range(H)]
Q=int(eval(input()))
X=[[0,0] for _ in range(H*W+1)]
for i in range(H):
for j in range(W):
X[A[i][j]][0]=i
X[A[i][j]][1]=j
M=[0]*(H*W+1)
for d in range(D+1,H*W+1):
M[d]=abs(X[d][0]-X[d-D][0])+abs(X[d][1]-X[d-D][1])+M[d-D]
for i in range(Q):
L,R=list(map(int,input().split()))
print((M[R]-M[L])) | 16 | 15 | 550 | 415 | H, W, D = list(map(int, input().split()))
A = [list(map(int, input().split())) for _ in range(H)]
Q = int(eval(input()))
X = [[[0, 0] for _ in range((H * W) // D + 1)] for _ in range(D)]
for i in range(H):
for j in range(W):
X[A[i][j] % D][A[i][j] // D][0] = i
X[A[i][j] % D][A[i][j] // D][1] = j
M = [[0] * ((H * W) // D + 1) for _ in range(D)]
for d in range(D):
for k in range((H * W) // D):
M[d][k + 1] = (
abs(X[d][k + 1][0] - X[d][k][0])
+ abs(X[d][k + 1][1] - X[d][k][1])
+ M[d][k]
)
for i in range(Q):
L, R = list(map(int, input().split()))
print((M[L % D][R // D] - M[L % D][L // D]))
| H, W, D = list(map(int, input().split()))
A = [list(map(int, input().split())) for _ in range(H)]
Q = int(eval(input()))
X = [[0, 0] for _ in range(H * W + 1)]
for i in range(H):
for j in range(W):
X[A[i][j]][0] = i
X[A[i][j]][1] = j
M = [0] * (H * W + 1)
for d in range(D + 1, H * W + 1):
M[d] = abs(X[d][0] - X[d - D][0]) + abs(X[d][1] - X[d - D][1]) + M[d - D]
for i in range(Q):
L, R = list(map(int, input().split()))
print((M[R] - M[L]))
| false | 6.25 | [
"-X = [[[0, 0] for _ in range((H * W) // D + 1)] for _ in range(D)]",
"+X = [[0, 0] for _ in range(H * W + 1)]",
"- X[A[i][j] % D][A[i][j] // D][0] = i",
"- X[A[i][j] % D][A[i][j] // D][1] = j",
"-M = [[0] * ((H * W) // D + 1) for _ in range(D)]",
"-for d in range(D):",
"- for k in range((H * W) // D):",
"- M[d][k + 1] = (",
"- abs(X[d][k + 1][0] - X[d][k][0])",
"- + abs(X[d][k + 1][1] - X[d][k][1])",
"- + M[d][k]",
"- )",
"+ X[A[i][j]][0] = i",
"+ X[A[i][j]][1] = j",
"+M = [0] * (H * W + 1)",
"+for d in range(D + 1, H * W + 1):",
"+ M[d] = abs(X[d][0] - X[d - D][0]) + abs(X[d][1] - X[d - D][1]) + M[d - D]",
"- print((M[L % D][R // D] - M[L % D][L // D]))",
"+ print((M[R] - M[L]))"
] | false | 0.041433 | 0.040649 | 1.019289 | [
"s380332994",
"s076806757"
] |
u347640436 | p03504 | python | s060132641 | s440771520 | 1,815 | 601 | 53,492 | 35,464 | Accepted | Accepted | 66.89 | N, C = list(map(int, input().split()))
tt = [[0] * (2 * 10 ** 5 + 1) for _ in range(30)]
for _ in range(N):
s, t, c = list(map(int, input().split()))
ttc = tt[c - 1]
for i in range(s * 2 - 1, t * 2):
ttc[i] = 1
ct = [0] * (2 * 10 ** 5 + 1)
for i in range(30):
tti = tt[i]
for j in range(2 * 10 ** 5 + 1):
ct[j] += tti[j]
print((max(ct)))
| from operator import itemgetter
N, C = list(map(int, input().split()))
stc = [list(map(int, input().split())) for _ in range(N)]
stc.sort(key=itemgetter(2, 0))
cs = [0] * (10 ** 5 * 2 + 1)
pc = -1
for s, t, c in stc:
if pc != c:
pt = -1
pc = c
if pt == s:
cs[s * 2] += 1
else:
cs[s * 2 - 1] += 1
cs[t * 2] -= 1
pt = t
for i in range(1, 10 ** 5 * 2 + 1):
cs[i] += cs[i - 1]
print((max(cs)))
| 16 | 23 | 378 | 464 | N, C = list(map(int, input().split()))
tt = [[0] * (2 * 10**5 + 1) for _ in range(30)]
for _ in range(N):
s, t, c = list(map(int, input().split()))
ttc = tt[c - 1]
for i in range(s * 2 - 1, t * 2):
ttc[i] = 1
ct = [0] * (2 * 10**5 + 1)
for i in range(30):
tti = tt[i]
for j in range(2 * 10**5 + 1):
ct[j] += tti[j]
print((max(ct)))
| from operator import itemgetter
N, C = list(map(int, input().split()))
stc = [list(map(int, input().split())) for _ in range(N)]
stc.sort(key=itemgetter(2, 0))
cs = [0] * (10**5 * 2 + 1)
pc = -1
for s, t, c in stc:
if pc != c:
pt = -1
pc = c
if pt == s:
cs[s * 2] += 1
else:
cs[s * 2 - 1] += 1
cs[t * 2] -= 1
pt = t
for i in range(1, 10**5 * 2 + 1):
cs[i] += cs[i - 1]
print((max(cs)))
| false | 30.434783 | [
"+from operator import itemgetter",
"+",
"-tt = [[0] * (2 * 10**5 + 1) for _ in range(30)]",
"-for _ in range(N):",
"- s, t, c = list(map(int, input().split()))",
"- ttc = tt[c - 1]",
"- for i in range(s * 2 - 1, t * 2):",
"- ttc[i] = 1",
"-ct = [0] * (2 * 10**5 + 1)",
"-for i in range(30):",
"- tti = tt[i]",
"- for j in range(2 * 10**5 + 1):",
"- ct[j] += tti[j]",
"-print((max(ct)))",
"+stc = [list(map(int, input().split())) for _ in range(N)]",
"+stc.sort(key=itemgetter(2, 0))",
"+cs = [0] * (10**5 * 2 + 1)",
"+pc = -1",
"+for s, t, c in stc:",
"+ if pc != c:",
"+ pt = -1",
"+ pc = c",
"+ if pt == s:",
"+ cs[s * 2] += 1",
"+ else:",
"+ cs[s * 2 - 1] += 1",
"+ cs[t * 2] -= 1",
"+ pt = t",
"+for i in range(1, 10**5 * 2 + 1):",
"+ cs[i] += cs[i - 1]",
"+print((max(cs)))"
] | false | 1.910332 | 0.128094 | 14.913471 | [
"s060132641",
"s440771520"
] |
u969850098 | p02702 | python | s997176100 | s512239024 | 131 | 119 | 25,436 | 17,912 | Accepted | Accepted | 9.16 | import sys
readline = sys.stdin.readline
from collections import Counter
MOD = 2019
def main():
S = list(map(int, list(readline().rstrip())))
N = len(S)
T = [0] * (N+1)
e = 1
for i in range(N-1, -1, -1):
T[i] = (T[i+1] + int(S[i]) * e) % MOD
e = e * 10 % MOD
T = [t % MOD for t in T]
c = Counter(T)
ans = 0
for k, v in list(c.items()):
ans += (v * (v-1)) // 2
print(ans)
if __name__ == '__main__':
main() | import sys
readline = sys.stdin.readline
from collections import Counter
MOD = 2019
def main():
S = list(map(int, list(readline().rstrip())))
N = len(S)
T = [0] * (N+1)
e = 1
for i in range(N-1, -1, -1):
T[i] = (T[i+1] + int(S[i]) * e) % MOD
e = e * 10 % MOD
c = Counter(T)
ans = 0
for k, v in list(c.items()):
ans += (v * (v-1)) // 2
print(ans)
if __name__ == '__main__':
main() | 24 | 23 | 497 | 467 | import sys
readline = sys.stdin.readline
from collections import Counter
MOD = 2019
def main():
S = list(map(int, list(readline().rstrip())))
N = len(S)
T = [0] * (N + 1)
e = 1
for i in range(N - 1, -1, -1):
T[i] = (T[i + 1] + int(S[i]) * e) % MOD
e = e * 10 % MOD
T = [t % MOD for t in T]
c = Counter(T)
ans = 0
for k, v in list(c.items()):
ans += (v * (v - 1)) // 2
print(ans)
if __name__ == "__main__":
main()
| import sys
readline = sys.stdin.readline
from collections import Counter
MOD = 2019
def main():
S = list(map(int, list(readline().rstrip())))
N = len(S)
T = [0] * (N + 1)
e = 1
for i in range(N - 1, -1, -1):
T[i] = (T[i + 1] + int(S[i]) * e) % MOD
e = e * 10 % MOD
c = Counter(T)
ans = 0
for k, v in list(c.items()):
ans += (v * (v - 1)) // 2
print(ans)
if __name__ == "__main__":
main()
| false | 4.166667 | [
"- T = [t % MOD for t in T]"
] | false | 0.043104 | 0.037952 | 1.13573 | [
"s997176100",
"s512239024"
] |
u909514237 | p02553 | python | s000087385 | s933700069 | 33 | 28 | 9,184 | 9,036 | Accepted | Accepted | 15.15 | a,b,c,d = list(map(int, input().split()))
t = list()
ac = a*c
bc = b*c
ad = a*d
bd = b*d
t.append(ac)
t.append(bc)
t.append(ad)
t.append(bd)
ans = -1 * 10**18
for i in range(4):
ans = max(t[i],ans)
print(ans) | a,b,c,d = list(map(int, input().split()))
ans = max(a*c, a*d, b*c, b*d)
print(ans) | 14 | 4 | 217 | 80 | a, b, c, d = list(map(int, input().split()))
t = list()
ac = a * c
bc = b * c
ad = a * d
bd = b * d
t.append(ac)
t.append(bc)
t.append(ad)
t.append(bd)
ans = -1 * 10**18
for i in range(4):
ans = max(t[i], ans)
print(ans)
| a, b, c, d = list(map(int, input().split()))
ans = max(a * c, a * d, b * c, b * d)
print(ans)
| false | 71.428571 | [
"-t = list()",
"-ac = a * c",
"-bc = b * c",
"-ad = a * d",
"-bd = b * d",
"-t.append(ac)",
"-t.append(bc)",
"-t.append(ad)",
"-t.append(bd)",
"-ans = -1 * 10**18",
"-for i in range(4):",
"- ans = max(t[i], ans)",
"+ans = max(a * c, a * d, b * c, b * d)"
] | false | 0.122665 | 0.03628 | 3.381022 | [
"s000087385",
"s933700069"
] |
u281610856 | p03290 | python | s389451866 | s232522779 | 65 | 18 | 3,192 | 3,064 | Accepted | Accepted | 72.31 | D, G = list(map(int, input().split()))
p = [0] * D
c = [0] * D
for i in range(D):
p[i], c[i] = list(map(int, input().split()))
ans = float('inf')
for bit in range(1 << D):
score = 0
cnt = 0
l = [0] * D
for j in range(D):
if (bit >> j) & 1 == 1:
score += p[j] * 100 * (j + 1) + c[j]
cnt += p[j]
l[j] = 1
if score < G:
idx = -1
for k, v in enumerate(l):
if v == 0:
idx = k
if idx != -1:
p_copy = p.copy()
while score < G and p_copy[idx] > 0:
score += (idx + 1) * 100
cnt += 1
p_copy[idx] -= 1
if score < G:
continue
ans = min(ans, cnt)
print(ans)
| D, G = list(map(int, input().split()))
p = [0] * (D + 1)
c = [0] * (D + 1)
for i in range(1, D+1):
p[i], c[i] = list(map(int, input().split()))
ans = float('inf')
def dfs(i, g):
global ans
if i == 0:
return ans
cnt = min(g // (100 * i), p[i])
score = 100 * i * cnt
if cnt == p[i]:
score += c[i]
if g > score:
cnt += dfs(i - 1, g - score)
return min(cnt, dfs(i - 1, g))
print((dfs(D, G))) | 30 | 22 | 770 | 454 | D, G = list(map(int, input().split()))
p = [0] * D
c = [0] * D
for i in range(D):
p[i], c[i] = list(map(int, input().split()))
ans = float("inf")
for bit in range(1 << D):
score = 0
cnt = 0
l = [0] * D
for j in range(D):
if (bit >> j) & 1 == 1:
score += p[j] * 100 * (j + 1) + c[j]
cnt += p[j]
l[j] = 1
if score < G:
idx = -1
for k, v in enumerate(l):
if v == 0:
idx = k
if idx != -1:
p_copy = p.copy()
while score < G and p_copy[idx] > 0:
score += (idx + 1) * 100
cnt += 1
p_copy[idx] -= 1
if score < G:
continue
ans = min(ans, cnt)
print(ans)
| D, G = list(map(int, input().split()))
p = [0] * (D + 1)
c = [0] * (D + 1)
for i in range(1, D + 1):
p[i], c[i] = list(map(int, input().split()))
ans = float("inf")
def dfs(i, g):
global ans
if i == 0:
return ans
cnt = min(g // (100 * i), p[i])
score = 100 * i * cnt
if cnt == p[i]:
score += c[i]
if g > score:
cnt += dfs(i - 1, g - score)
return min(cnt, dfs(i - 1, g))
print((dfs(D, G)))
| false | 26.666667 | [
"-p = [0] * D",
"-c = [0] * D",
"-for i in range(D):",
"+p = [0] * (D + 1)",
"+c = [0] * (D + 1)",
"+for i in range(1, D + 1):",
"-for bit in range(1 << D):",
"- score = 0",
"- cnt = 0",
"- l = [0] * D",
"- for j in range(D):",
"- if (bit >> j) & 1 == 1:",
"- score += p[j] * 100 * (j + 1) + c[j]",
"- cnt += p[j]",
"- l[j] = 1",
"- if score < G:",
"- idx = -1",
"- for k, v in enumerate(l):",
"- if v == 0:",
"- idx = k",
"- if idx != -1:",
"- p_copy = p.copy()",
"- while score < G and p_copy[idx] > 0:",
"- score += (idx + 1) * 100",
"- cnt += 1",
"- p_copy[idx] -= 1",
"- if score < G:",
"- continue",
"- ans = min(ans, cnt)",
"-print(ans)",
"+",
"+",
"+def dfs(i, g):",
"+ global ans",
"+ if i == 0:",
"+ return ans",
"+ cnt = min(g // (100 * i), p[i])",
"+ score = 100 * i * cnt",
"+ if cnt == p[i]:",
"+ score += c[i]",
"+ if g > score:",
"+ cnt += dfs(i - 1, g - score)",
"+ return min(cnt, dfs(i - 1, g))",
"+",
"+",
"+print((dfs(D, G)))"
] | false | 0.072663 | 0.036247 | 2.004633 | [
"s389451866",
"s232522779"
] |
u477977638 | p02644 | python | s579615844 | s968805182 | 1,086 | 644 | 281,504 | 282,940 | Accepted | Accepted | 40.7 | import sys
read = sys.stdin.buffer.read
input = sys.stdin.readline
#input = sys.stdin.buffer.readline
#sys.setrecursionlimit(10**9)
#from functools import lru_cache
def RD(): return sys.stdin.read()
def II(): return int(eval(input()))
def MI(): return list(map(int,input().split()))
def MF(): return list(map(float,input().split()))
def LI(): return list(map(int,input().split()))
def LF(): return list(map(float,input().split()))
def TI(): return tuple(map(int,input().split()))
# rstrip().decode('utf-8')
from collections import deque
def main():
h,w,k=MI()
x1,y1,x2,y2=MI()
G=["@"]*(w+2)
for _ in range(h):
G.append("@")
G+=(list(map(str,input().rstrip())))
G.append("@")
G+=["@"]*(w+2)
#print(G)
G[x1*(w+2)+y1]=0
#print(G)
Q=deque()
Q.append((x1*(w+2)+y1,0))
while Q:
#print(Q)
now,d=Q.popleft()
#print(Q)
for i in range(1,k+1):
if G[now+i]==d or G[now+i]=="@":
break
elif G[now+i]==".":
G[now+i]=d+1
Q.append([now+i,d+1])
elif G[now+i]==d+1:
continue
else:
break
for i in range(1,k+1):
if G[now-i]==d or G[now-i]=="@":
break
elif G[now-i]==".":
G[now-i]=d+1
Q.append([now-i,d+1])
elif G[now-i]==d+1:
continue
else:
break
for i in range(1,k+1):
if G[now+(w+2)*i]==d or G[now+(w+2)*i]=="@":
break
elif G[now+(w+2)*i]==".":
G[now+(w+2)*i]=d+1
Q.append([now+(w+2)*i,d+1])
elif G[now+(w+2)*i]==d+1:
continue
else:
break
for i in range(1,k+1):
if G[now-(w+2)*i]==d or G[now-(w+2)*i]=="@":
break
elif G[now-(w+2)*i]==".":
G[now-(w+2)*i]=d+1
Q.append([now-(w+2)*i,d+1])
elif G[now-(w+2)*i]==d+1:
continue
else:
break
#print(Q)
#print(G)
if G[x2*(w+2)+y2]==".":
print((-1))
else:
print((G[x2*(w+2)+y2]))
if __name__ == "__main__":
main()
| import sys
read = sys.stdin.buffer.read
input = sys.stdin.readline
#input = sys.stdin.buffer.readline
#sys.setrecursionlimit(10**9)
#from functools import lru_cache
def RD(): return sys.stdin.read()
def II(): return int(eval(input()))
def MI(): return list(map(int,input().split()))
def MF(): return list(map(float,input().split()))
def LI(): return list(map(int,input().split()))
def LF(): return list(map(float,input().split()))
def TI(): return tuple(map(int,input().split()))
# rstrip().decode('utf-8')
from collections import deque
def main():
h,w,k=MI()
x1,y1,x2,y2=MI()
G=["@"]*(w+2)
for _ in range(h):
G.append("@")
G+=(list(map(str,input().rstrip())))
G.append("@")
G+=["@"]*(w+2)
#print(G)
G[x1*(w+2)+y1]=0
#print(G)
Q=deque()
Q.append((x1*(w+2)+y1,0))
while Q:
#print(Q)
now,d=Q.popleft()
#print(Q)
for m in [1,-1,w+2,-w-2]:
for i in range(1,k+1):
if G[now+m*i]==d or G[now+m*i]=="@":
break
elif G[now+m*i]==".":
G[now+m*i]=d+1
Q.append([now+m*i,d+1])
elif G[now+m*i]==d+1:
continue
else:
break
#print(Q)
#print(G)
if G[x2*(w+2)+y2]==".":
print((-1))
else:
print((G[x2*(w+2)+y2]))
if __name__ == "__main__":
main()
| 98 | 65 | 1,895 | 1,260 | import sys
read = sys.stdin.buffer.read
input = sys.stdin.readline
# input = sys.stdin.buffer.readline
# sys.setrecursionlimit(10**9)
# from functools import lru_cache
def RD():
return sys.stdin.read()
def II():
return int(eval(input()))
def MI():
return list(map(int, input().split()))
def MF():
return list(map(float, input().split()))
def LI():
return list(map(int, input().split()))
def LF():
return list(map(float, input().split()))
def TI():
return tuple(map(int, input().split()))
# rstrip().decode('utf-8')
from collections import deque
def main():
h, w, k = MI()
x1, y1, x2, y2 = MI()
G = ["@"] * (w + 2)
for _ in range(h):
G.append("@")
G += list(map(str, input().rstrip()))
G.append("@")
G += ["@"] * (w + 2)
# print(G)
G[x1 * (w + 2) + y1] = 0
# print(G)
Q = deque()
Q.append((x1 * (w + 2) + y1, 0))
while Q:
# print(Q)
now, d = Q.popleft()
# print(Q)
for i in range(1, k + 1):
if G[now + i] == d or G[now + i] == "@":
break
elif G[now + i] == ".":
G[now + i] = d + 1
Q.append([now + i, d + 1])
elif G[now + i] == d + 1:
continue
else:
break
for i in range(1, k + 1):
if G[now - i] == d or G[now - i] == "@":
break
elif G[now - i] == ".":
G[now - i] = d + 1
Q.append([now - i, d + 1])
elif G[now - i] == d + 1:
continue
else:
break
for i in range(1, k + 1):
if G[now + (w + 2) * i] == d or G[now + (w + 2) * i] == "@":
break
elif G[now + (w + 2) * i] == ".":
G[now + (w + 2) * i] = d + 1
Q.append([now + (w + 2) * i, d + 1])
elif G[now + (w + 2) * i] == d + 1:
continue
else:
break
for i in range(1, k + 1):
if G[now - (w + 2) * i] == d or G[now - (w + 2) * i] == "@":
break
elif G[now - (w + 2) * i] == ".":
G[now - (w + 2) * i] = d + 1
Q.append([now - (w + 2) * i, d + 1])
elif G[now - (w + 2) * i] == d + 1:
continue
else:
break
# print(Q)
# print(G)
if G[x2 * (w + 2) + y2] == ".":
print((-1))
else:
print((G[x2 * (w + 2) + y2]))
if __name__ == "__main__":
main()
| import sys
read = sys.stdin.buffer.read
input = sys.stdin.readline
# input = sys.stdin.buffer.readline
# sys.setrecursionlimit(10**9)
# from functools import lru_cache
def RD():
return sys.stdin.read()
def II():
return int(eval(input()))
def MI():
return list(map(int, input().split()))
def MF():
return list(map(float, input().split()))
def LI():
return list(map(int, input().split()))
def LF():
return list(map(float, input().split()))
def TI():
return tuple(map(int, input().split()))
# rstrip().decode('utf-8')
from collections import deque
def main():
h, w, k = MI()
x1, y1, x2, y2 = MI()
G = ["@"] * (w + 2)
for _ in range(h):
G.append("@")
G += list(map(str, input().rstrip()))
G.append("@")
G += ["@"] * (w + 2)
# print(G)
G[x1 * (w + 2) + y1] = 0
# print(G)
Q = deque()
Q.append((x1 * (w + 2) + y1, 0))
while Q:
# print(Q)
now, d = Q.popleft()
# print(Q)
for m in [1, -1, w + 2, -w - 2]:
for i in range(1, k + 1):
if G[now + m * i] == d or G[now + m * i] == "@":
break
elif G[now + m * i] == ".":
G[now + m * i] = d + 1
Q.append([now + m * i, d + 1])
elif G[now + m * i] == d + 1:
continue
else:
break
# print(Q)
# print(G)
if G[x2 * (w + 2) + y2] == ".":
print((-1))
else:
print((G[x2 * (w + 2) + y2]))
if __name__ == "__main__":
main()
| false | 33.673469 | [
"- for i in range(1, k + 1):",
"- if G[now + i] == d or G[now + i] == \"@\":",
"- break",
"- elif G[now + i] == \".\":",
"- G[now + i] = d + 1",
"- Q.append([now + i, d + 1])",
"- elif G[now + i] == d + 1:",
"- continue",
"- else:",
"- break",
"- for i in range(1, k + 1):",
"- if G[now - i] == d or G[now - i] == \"@\":",
"- break",
"- elif G[now - i] == \".\":",
"- G[now - i] = d + 1",
"- Q.append([now - i, d + 1])",
"- elif G[now - i] == d + 1:",
"- continue",
"- else:",
"- break",
"- for i in range(1, k + 1):",
"- if G[now + (w + 2) * i] == d or G[now + (w + 2) * i] == \"@\":",
"- break",
"- elif G[now + (w + 2) * i] == \".\":",
"- G[now + (w + 2) * i] = d + 1",
"- Q.append([now + (w + 2) * i, d + 1])",
"- elif G[now + (w + 2) * i] == d + 1:",
"- continue",
"- else:",
"- break",
"- for i in range(1, k + 1):",
"- if G[now - (w + 2) * i] == d or G[now - (w + 2) * i] == \"@\":",
"- break",
"- elif G[now - (w + 2) * i] == \".\":",
"- G[now - (w + 2) * i] = d + 1",
"- Q.append([now - (w + 2) * i, d + 1])",
"- elif G[now - (w + 2) * i] == d + 1:",
"- continue",
"- else:",
"- break",
"+ for m in [1, -1, w + 2, -w - 2]:",
"+ for i in range(1, k + 1):",
"+ if G[now + m * i] == d or G[now + m * i] == \"@\":",
"+ break",
"+ elif G[now + m * i] == \".\":",
"+ G[now + m * i] = d + 1",
"+ Q.append([now + m * i, d + 1])",
"+ elif G[now + m * i] == d + 1:",
"+ continue",
"+ else:",
"+ break"
] | false | 0.042252 | 0.037624 | 1.122997 | [
"s579615844",
"s968805182"
] |
u761320129 | p03501 | python | s814348247 | s820215547 | 20 | 17 | 3,316 | 2,940 | Accepted | Accepted | 15 | N,A,B = list(map(int,input().split()))
print((min(N*A, B)))
| N,A,B = list(map(int,input().split()))
print((min(B,N*A))) | 2 | 2 | 53 | 51 | N, A, B = list(map(int, input().split()))
print((min(N * A, B)))
| N, A, B = list(map(int, input().split()))
print((min(B, N * A)))
| false | 0 | [
"-print((min(N * A, B)))",
"+print((min(B, N * A)))"
] | false | 0.051843 | 0.12695 | 0.408376 | [
"s814348247",
"s820215547"
] |
u888092736 | p03018 | python | s612951599 | s101299214 | 216 | 52 | 13,564 | 9,260 | Accepted | Accepted | 75.93 | class FenwickTree:
def __init__(self, n):
self.n = n
self.data = [0] * (n + 1)
self.k_init = 2 ** (self.n - 1).bit_length()
def sum(self, i):
s = 0
while i > 0:
s += self.data[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.n:
self.data[i] += x
i += i & -i
def get_invnum(li):
n = len(li)
t = FenwickTree(2)
res = 0
for i in range(n):
if li[i] == "A":
t.add(2, 1)
else:
res += t.sum(2)
return res
S = eval(input())
S = list(S.replace("BC", "D"))
N = len(S)
li = []
ans = 0
for c in S + ["B"]:
if c not in ("A", "D"):
ans += get_invnum(li)
li = []
else:
li.append(c)
print(ans)
| S = eval(input())
S = S.replace("BC", "D")
cur = 0
ans = 0
for c in S:
if c == "A":
cur += 1
elif c == "D":
ans += cur
else:
cur = 0
print(ans)
| 43 | 12 | 840 | 185 | class FenwickTree:
def __init__(self, n):
self.n = n
self.data = [0] * (n + 1)
self.k_init = 2 ** (self.n - 1).bit_length()
def sum(self, i):
s = 0
while i > 0:
s += self.data[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.n:
self.data[i] += x
i += i & -i
def get_invnum(li):
n = len(li)
t = FenwickTree(2)
res = 0
for i in range(n):
if li[i] == "A":
t.add(2, 1)
else:
res += t.sum(2)
return res
S = eval(input())
S = list(S.replace("BC", "D"))
N = len(S)
li = []
ans = 0
for c in S + ["B"]:
if c not in ("A", "D"):
ans += get_invnum(li)
li = []
else:
li.append(c)
print(ans)
| S = eval(input())
S = S.replace("BC", "D")
cur = 0
ans = 0
for c in S:
if c == "A":
cur += 1
elif c == "D":
ans += cur
else:
cur = 0
print(ans)
| false | 72.093023 | [
"-class FenwickTree:",
"- def __init__(self, n):",
"- self.n = n",
"- self.data = [0] * (n + 1)",
"- self.k_init = 2 ** (self.n - 1).bit_length()",
"-",
"- def sum(self, i):",
"- s = 0",
"- while i > 0:",
"- s += self.data[i]",
"- i -= i & -i",
"- return s",
"-",
"- def add(self, i, x):",
"- while i <= self.n:",
"- self.data[i] += x",
"- i += i & -i",
"-",
"-",
"-def get_invnum(li):",
"- n = len(li)",
"- t = FenwickTree(2)",
"- res = 0",
"- for i in range(n):",
"- if li[i] == \"A\":",
"- t.add(2, 1)",
"- else:",
"- res += t.sum(2)",
"- return res",
"-",
"-",
"-S = list(S.replace(\"BC\", \"D\"))",
"-N = len(S)",
"-li = []",
"+S = S.replace(\"BC\", \"D\")",
"+cur = 0",
"-for c in S + [\"B\"]:",
"- if c not in (\"A\", \"D\"):",
"- ans += get_invnum(li)",
"- li = []",
"+for c in S:",
"+ if c == \"A\":",
"+ cur += 1",
"+ elif c == \"D\":",
"+ ans += cur",
"- li.append(c)",
"+ cur = 0"
] | false | 0.035568 | 0.073604 | 0.48324 | [
"s612951599",
"s101299214"
] |
u348805958 | p02762 | python | s230789008 | s052115752 | 1,224 | 990 | 42,724 | 10,992 | Accepted | Accepted | 19.12 | #!python3
iim = lambda: list(map(int, input().rstrip().split()))
from bisect import bisect
def resolve():
def find(i):
x = S[i]
if x < 0:
return i
S[i] = find(x)
return S[i]
def join(i, j):
ai = find(i)
aj = find(j)
diff = ai - aj
#print("j", ai, aj)
if diff == 0:
return
elif diff > 0:
ai, aj = aj, ai
S[ai] += S[aj]
S[aj] = ai
def same(i, j):
ai = find(i)
aj = find(j)
return ai == aj
def size(i):
return -S[find(i)]
N, M, K = iim()
S = [-1] * N
T = [1] * N
for i in range(M):
ai, bi = iim()
ai -= 1; bi -= 1
join(ai, bi)
T[ai] += 1
T[bi] += 1
#print(ai, bi, S)
U = [set() for i in range(N)]
for i in range(K):
ai, bi = iim()
ai -= 1; bi -= 1
U[ai].add(bi)
U[bi].add(ai)
#print(S)
#print(T)
ans = [size(i) - T[i] - sum(same(i, j) for j in U[i]) for i in range(N)]
print((*ans))
if __name__ == "__main__":
resolve()
| #!python3
iim = lambda: list(map(int, input().rstrip().split()))
from bisect import bisect
def resolve():
def find(i):
x = S[i]
if x < 0:
return i
S[i] = find(x)
return S[i]
def join(i, j):
ai = find(i)
aj = find(j)
diff = ai - aj
if diff == 0:
return
elif diff > 0:
ai, aj = aj, ai
S[ai] += S[aj]
S[aj] = ai
def same(i, j):
ai = find(i)
aj = find(j)
return ai == aj
def size(i):
return -S[find(i)]
N, M, K = iim()
S = [-1] * N
T = [1] * N
for i in range(M):
ai, bi = iim()
ai -= 1; bi -= 1
join(ai, bi)
T[ai] += 1
T[bi] += 1
#print(ai, bi, S)
for i in range(K):
ai, bi = iim()
ai -= 1; bi -= 1
if same(ai, bi):
T[ai] += 1
T[bi] += 1
#print(S)
#print(T)
ans = [size(i) - T[i] for i in range(N)]
print((*ans))
if __name__ == "__main__":
resolve()
| 58 | 57 | 1,179 | 1,111 | #!python3
iim = lambda: list(map(int, input().rstrip().split()))
from bisect import bisect
def resolve():
def find(i):
x = S[i]
if x < 0:
return i
S[i] = find(x)
return S[i]
def join(i, j):
ai = find(i)
aj = find(j)
diff = ai - aj
# print("j", ai, aj)
if diff == 0:
return
elif diff > 0:
ai, aj = aj, ai
S[ai] += S[aj]
S[aj] = ai
def same(i, j):
ai = find(i)
aj = find(j)
return ai == aj
def size(i):
return -S[find(i)]
N, M, K = iim()
S = [-1] * N
T = [1] * N
for i in range(M):
ai, bi = iim()
ai -= 1
bi -= 1
join(ai, bi)
T[ai] += 1
T[bi] += 1
# print(ai, bi, S)
U = [set() for i in range(N)]
for i in range(K):
ai, bi = iim()
ai -= 1
bi -= 1
U[ai].add(bi)
U[bi].add(ai)
# print(S)
# print(T)
ans = [size(i) - T[i] - sum(same(i, j) for j in U[i]) for i in range(N)]
print((*ans))
if __name__ == "__main__":
resolve()
| #!python3
iim = lambda: list(map(int, input().rstrip().split()))
from bisect import bisect
def resolve():
def find(i):
x = S[i]
if x < 0:
return i
S[i] = find(x)
return S[i]
def join(i, j):
ai = find(i)
aj = find(j)
diff = ai - aj
if diff == 0:
return
elif diff > 0:
ai, aj = aj, ai
S[ai] += S[aj]
S[aj] = ai
def same(i, j):
ai = find(i)
aj = find(j)
return ai == aj
def size(i):
return -S[find(i)]
N, M, K = iim()
S = [-1] * N
T = [1] * N
for i in range(M):
ai, bi = iim()
ai -= 1
bi -= 1
join(ai, bi)
T[ai] += 1
T[bi] += 1
# print(ai, bi, S)
for i in range(K):
ai, bi = iim()
ai -= 1
bi -= 1
if same(ai, bi):
T[ai] += 1
T[bi] += 1
# print(S)
# print(T)
ans = [size(i) - T[i] for i in range(N)]
print((*ans))
if __name__ == "__main__":
resolve()
| false | 1.724138 | [
"- # print(\"j\", ai, aj)",
"- U = [set() for i in range(N)]",
"- U[ai].add(bi)",
"- U[bi].add(ai)",
"+ if same(ai, bi):",
"+ T[ai] += 1",
"+ T[bi] += 1",
"- ans = [size(i) - T[i] - sum(same(i, j) for j in U[i]) for i in range(N)]",
"+ ans = [size(i) - T[i] for i in range(N)]"
] | false | 0.007993 | 0.174966 | 0.045681 | [
"s230789008",
"s052115752"
] |
u200887663 | p03457 | python | s966141273 | s374087570 | 424 | 242 | 27,380 | 9,104 | Accepted | Accepted | 42.92 | n=int(eval(input()))
li=[list(map(int,input().split())) for i in range(n)]
li.insert(0,[0,0,0])
#print(li)
for i in range(n) :
cr=li[i]
nx=li[i+1]
dist=abs(nx[1]-cr[1])+abs(nx[2]-cr[2])
dt=nx[0]-cr[0]
if dt<dist :
print("No")
exit()
if (dt%2) != (dist%2) :
print("No")
exit()
print("Yes") | n=int(eval(input()))
#a,b=map(int,input().split())
#l=list(map(int,input().split()))
#l=[list(map(int,input().split())) for i in range(n)]
t_bef=0
x_bef=0
y_bef=0
flag='Yes'
for i in range(1,n+1):
t,x,y=list(map(int,input().split()))
dt=t-t_bef
dist=abs(x-x_bef)+abs(y-y_bef)
if (dt%2 != dist%2) or dist>dt:
flag='No'
#break
t_bef,x_bef,y_bef=t,x,y
print(flag) | 18 | 19 | 329 | 404 | n = int(eval(input()))
li = [list(map(int, input().split())) for i in range(n)]
li.insert(0, [0, 0, 0])
# print(li)
for i in range(n):
cr = li[i]
nx = li[i + 1]
dist = abs(nx[1] - cr[1]) + abs(nx[2] - cr[2])
dt = nx[0] - cr[0]
if dt < dist:
print("No")
exit()
if (dt % 2) != (dist % 2):
print("No")
exit()
print("Yes")
| n = int(eval(input()))
# a,b=map(int,input().split())
# l=list(map(int,input().split()))
# l=[list(map(int,input().split())) for i in range(n)]
t_bef = 0
x_bef = 0
y_bef = 0
flag = "Yes"
for i in range(1, n + 1):
t, x, y = list(map(int, input().split()))
dt = t - t_bef
dist = abs(x - x_bef) + abs(y - y_bef)
if (dt % 2 != dist % 2) or dist > dt:
flag = "No"
# break
t_bef, x_bef, y_bef = t, x, y
print(flag)
| false | 5.263158 | [
"-li = [list(map(int, input().split())) for i in range(n)]",
"-li.insert(0, [0, 0, 0])",
"-# print(li)",
"-for i in range(n):",
"- cr = li[i]",
"- nx = li[i + 1]",
"- dist = abs(nx[1] - cr[1]) + abs(nx[2] - cr[2])",
"- dt = nx[0] - cr[0]",
"- if dt < dist:",
"- print(\"No\")",
"- exit()",
"- if (dt % 2) != (dist % 2):",
"- print(\"No\")",
"- exit()",
"-print(\"Yes\")",
"+# a,b=map(int,input().split())",
"+# l=list(map(int,input().split()))",
"+# l=[list(map(int,input().split())) for i in range(n)]",
"+t_bef = 0",
"+x_bef = 0",
"+y_bef = 0",
"+flag = \"Yes\"",
"+for i in range(1, n + 1):",
"+ t, x, y = list(map(int, input().split()))",
"+ dt = t - t_bef",
"+ dist = abs(x - x_bef) + abs(y - y_bef)",
"+ if (dt % 2 != dist % 2) or dist > dt:",
"+ flag = \"No\"",
"+ # break",
"+ t_bef, x_bef, y_bef = t, x, y",
"+print(flag)"
] | false | 0.037975 | 0.007976 | 4.761384 | [
"s966141273",
"s374087570"
] |
u624475441 | p03291 | python | s272158272 | s120174294 | 146 | 102 | 3,188 | 3,188 | Accepted | Accepted | 30.14 | M = 10**9 + 7
dp = [0] * 4
dp[0] = 1
idx = {'A': 1, 'B': 2, 'C': 3}
m = lambda x: x % M if x > M else x
for c in eval(input()):
if c == '?':
N, A, AB, ABC = dp
dp = [m(N * 3), m(A * 3 + N), m(AB * 3 + A), m(ABC * 3 + AB)]
else:
dp[idx[c]] += dp[idx[c] - 1]
print((dp[3] % M)) | M = 10**9 + 7
N, A, AB, ABC = 1, 0, 0, 0
idx = {'A': 1, 'B': 2, 'C': 3}
for c in eval(input()):
if c == '?':
N, A, AB, ABC = (N * 3) % M, (A * 3 + N) % M, (AB * 3 + A) % M, (ABC * 3 + AB) % M
else:
dp = [N, A, AB, ABC]
dp[idx[c]] += dp[idx[c] - 1]
N, A, AB, ABC = dp
print((ABC % M)) | 12 | 11 | 310 | 325 | M = 10**9 + 7
dp = [0] * 4
dp[0] = 1
idx = {"A": 1, "B": 2, "C": 3}
m = lambda x: x % M if x > M else x
for c in eval(input()):
if c == "?":
N, A, AB, ABC = dp
dp = [m(N * 3), m(A * 3 + N), m(AB * 3 + A), m(ABC * 3 + AB)]
else:
dp[idx[c]] += dp[idx[c] - 1]
print((dp[3] % M))
| M = 10**9 + 7
N, A, AB, ABC = 1, 0, 0, 0
idx = {"A": 1, "B": 2, "C": 3}
for c in eval(input()):
if c == "?":
N, A, AB, ABC = (
(N * 3) % M,
(A * 3 + N) % M,
(AB * 3 + A) % M,
(ABC * 3 + AB) % M,
)
else:
dp = [N, A, AB, ABC]
dp[idx[c]] += dp[idx[c] - 1]
N, A, AB, ABC = dp
print((ABC % M))
| false | 8.333333 | [
"-dp = [0] * 4",
"-dp[0] = 1",
"+N, A, AB, ABC = 1, 0, 0, 0",
"-m = lambda x: x % M if x > M else x",
"+ N, A, AB, ABC = (",
"+ (N * 3) % M,",
"+ (A * 3 + N) % M,",
"+ (AB * 3 + A) % M,",
"+ (ABC * 3 + AB) % M,",
"+ )",
"+ else:",
"+ dp = [N, A, AB, ABC]",
"+ dp[idx[c]] += dp[idx[c] - 1]",
"- dp = [m(N * 3), m(A * 3 + N), m(AB * 3 + A), m(ABC * 3 + AB)]",
"- else:",
"- dp[idx[c]] += dp[idx[c] - 1]",
"-print((dp[3] % M))",
"+print((ABC % M))"
] | false | 0.059798 | 0.041029 | 1.457458 | [
"s272158272",
"s120174294"
] |
u966695411 | p03864 | python | s932276991 | s509157121 | 177 | 118 | 14,592 | 14,132 | Accepted | Accepted | 33.33 | #! /usr/bin/env python3
N, x = list(map(int, input().split()))
C = list(map(int, input().split()))
cnt = 0
for i in range(N-1):
if C[i]+C[i+1] > x:
a = C[i]+C[i+1] - x
cnt += a
C[i] = min(C[i+1]-a, 0)
C[i+1] = max(C[i+1]-a, 0)
print(cnt) | #! /usr/bin/env python3
N, M = list(map(int, input().split()))
cnt = 0
a = list(map(int, input().split())) + [0]
for i in range(N):
if a[i] + a[i+1] > M:
o = a[i] + a[i+1] - M
cnt += o
if o > a[i+1]:
o -= a[i+1]
a[i+1] = 0
# a[i] -= o
else:
a[i+1] -= o
print(cnt) | 12 | 16 | 279 | 357 | #! /usr/bin/env python3
N, x = list(map(int, input().split()))
C = list(map(int, input().split()))
cnt = 0
for i in range(N - 1):
if C[i] + C[i + 1] > x:
a = C[i] + C[i + 1] - x
cnt += a
C[i] = min(C[i + 1] - a, 0)
C[i + 1] = max(C[i + 1] - a, 0)
print(cnt)
| #! /usr/bin/env python3
N, M = list(map(int, input().split()))
cnt = 0
a = list(map(int, input().split())) + [0]
for i in range(N):
if a[i] + a[i + 1] > M:
o = a[i] + a[i + 1] - M
cnt += o
if o > a[i + 1]:
o -= a[i + 1]
a[i + 1] = 0
# a[i] -= o
else:
a[i + 1] -= o
print(cnt)
| false | 25 | [
"-N, x = list(map(int, input().split()))",
"-C = list(map(int, input().split()))",
"+N, M = list(map(int, input().split()))",
"-for i in range(N - 1):",
"- if C[i] + C[i + 1] > x:",
"- a = C[i] + C[i + 1] - x",
"- cnt += a",
"- C[i] = min(C[i + 1] - a, 0)",
"- C[i + 1] = max(C[i + 1] - a, 0)",
"+a = list(map(int, input().split())) + [0]",
"+for i in range(N):",
"+ if a[i] + a[i + 1] > M:",
"+ o = a[i] + a[i + 1] - M",
"+ cnt += o",
"+ if o > a[i + 1]:",
"+ o -= a[i + 1]",
"+ a[i + 1] = 0",
"+ # a[i] -= o",
"+ else:",
"+ a[i + 1] -= o"
] | false | 0.044287 | 0.046927 | 0.943749 | [
"s932276991",
"s509157121"
] |
u771007149 | p02732 | python | s373604959 | s873465827 | 380 | 224 | 26,780 | 34,220 | Accepted | Accepted | 41.05 | import collections
n = int(eval(input()))
a = list(map(int,input().split()))
cnt = 0
c = collections.Counter(a)
for i in list(c.values()):
cnt += i*(i-1) // 2
for j in range(n):
print((cnt - c[a[j]] + 1)) | from collections import Counter
n = int(eval(input()))
a = list(map(int,input().split()))
c = Counter(a)
#print(c)
s = 0
for i in list(c.values()):
s += i * (i-1) // 2
for i in range(n):
print((s - c[a[i]] + 1)) | 9 | 13 | 206 | 220 | import collections
n = int(eval(input()))
a = list(map(int, input().split()))
cnt = 0
c = collections.Counter(a)
for i in list(c.values()):
cnt += i * (i - 1) // 2
for j in range(n):
print((cnt - c[a[j]] + 1))
| from collections import Counter
n = int(eval(input()))
a = list(map(int, input().split()))
c = Counter(a)
# print(c)
s = 0
for i in list(c.values()):
s += i * (i - 1) // 2
for i in range(n):
print((s - c[a[i]] + 1))
| false | 30.769231 | [
"-import collections",
"+from collections import Counter",
"-cnt = 0",
"-c = collections.Counter(a)",
"+c = Counter(a)",
"+# print(c)",
"+s = 0",
"- cnt += i * (i - 1) // 2",
"-for j in range(n):",
"- print((cnt - c[a[j]] + 1))",
"+ s += i * (i - 1) // 2",
"+for i in range(n):",
"+ print((s - c[a[i]] + 1))"
] | false | 0.04156 | 0.115904 | 0.358575 | [
"s373604959",
"s873465827"
] |
u891847179 | p02726 | python | s468505970 | s892031915 | 1,929 | 1,618 | 3,444 | 3,444 | Accepted | Accepted | 16.12 | N, X, Y = list(map(int, input().split()))
res = [0] * N
for i in range(1, N + 1):
for j in range(1, N + 1):
if i >= j:
continue
if i == X and Y == j:
key = 1
else:
key = int(min(j - i, abs(X - i) + abs(Y - j) + 1))
res[key] += 1
for i in range(1, N):
print((res[i]))
| N, X, Y = list(map(int, input().split()))
res = [0] * N
for j in range(1, N + 1):
for i in range(1, j):
if i == X and Y == j:
key = 1
else:
key = int(min(j - i, abs(X - i) + abs(Y - j) + 1))
res[key] += 1
for i in range(1, N):
print((res[i])) | 14 | 12 | 355 | 308 | N, X, Y = list(map(int, input().split()))
res = [0] * N
for i in range(1, N + 1):
for j in range(1, N + 1):
if i >= j:
continue
if i == X and Y == j:
key = 1
else:
key = int(min(j - i, abs(X - i) + abs(Y - j) + 1))
res[key] += 1
for i in range(1, N):
print((res[i]))
| N, X, Y = list(map(int, input().split()))
res = [0] * N
for j in range(1, N + 1):
for i in range(1, j):
if i == X and Y == j:
key = 1
else:
key = int(min(j - i, abs(X - i) + abs(Y - j) + 1))
res[key] += 1
for i in range(1, N):
print((res[i]))
| false | 14.285714 | [
"-for i in range(1, N + 1):",
"- for j in range(1, N + 1):",
"- if i >= j:",
"- continue",
"+for j in range(1, N + 1):",
"+ for i in range(1, j):"
] | false | 0.075554 | 0.035707 | 2.115968 | [
"s468505970",
"s892031915"
] |
u393253137 | p03361 | python | s357749092 | s016806519 | 20 | 18 | 3,064 | 3,064 | Accepted | Accepted | 10 | h,w=list(map(int,input().split()))
s=list(eval(input()) for _ in range(h))
flag=1
for i in range(h):
for j in range(w):
check=0
if s[i][j]=="#":
if i!=0 and s[i-1][j]=="#":check +=1
if i!=h-1 and s[i+1][j]=="#":check += 1
if j!=0 and s[i][j-1]=="#":check += 1
if j!=w-1 and s[i][j+1]=="#":check += 1
if check==0:flag=0
print(("Yes" if flag else "No")) | h,w=list(map(int,input().split()))
#枠を大きめに確保してout of rangeを避ける!
grid = ["."*(w+2)]
for _ in range(h):
grid.append("." + eval(input()) + ".")
grid += ["."*(w+2)]
for i in range(1,h+1):
for j in range(1,w+1):
if grid[i][j]=="#":
if not (grid[i][j-1]=="#" or grid[i][j+1]=="#"or \
grid[i-1][j]=="#" or grid[i+1][j]=="#"):
print("No")
exit()
print("Yes") | 13 | 15 | 429 | 437 | h, w = list(map(int, input().split()))
s = list(eval(input()) for _ in range(h))
flag = 1
for i in range(h):
for j in range(w):
check = 0
if s[i][j] == "#":
if i != 0 and s[i - 1][j] == "#":
check += 1
if i != h - 1 and s[i + 1][j] == "#":
check += 1
if j != 0 and s[i][j - 1] == "#":
check += 1
if j != w - 1 and s[i][j + 1] == "#":
check += 1
if check == 0:
flag = 0
print(("Yes" if flag else "No"))
| h, w = list(map(int, input().split()))
# 枠を大きめに確保してout of rangeを避ける!
grid = ["." * (w + 2)]
for _ in range(h):
grid.append("." + eval(input()) + ".")
grid += ["." * (w + 2)]
for i in range(1, h + 1):
for j in range(1, w + 1):
if grid[i][j] == "#":
if not (
grid[i][j - 1] == "#"
or grid[i][j + 1] == "#"
or grid[i - 1][j] == "#"
or grid[i + 1][j] == "#"
):
print("No")
exit()
print("Yes")
| false | 13.333333 | [
"-s = list(eval(input()) for _ in range(h))",
"-flag = 1",
"-for i in range(h):",
"- for j in range(w):",
"- check = 0",
"- if s[i][j] == \"#\":",
"- if i != 0 and s[i - 1][j] == \"#\":",
"- check += 1",
"- if i != h - 1 and s[i + 1][j] == \"#\":",
"- check += 1",
"- if j != 0 and s[i][j - 1] == \"#\":",
"- check += 1",
"- if j != w - 1 and s[i][j + 1] == \"#\":",
"- check += 1",
"- if check == 0:",
"- flag = 0",
"-print((\"Yes\" if flag else \"No\"))",
"+# 枠を大きめに確保してout of rangeを避ける!",
"+grid = [\".\" * (w + 2)]",
"+for _ in range(h):",
"+ grid.append(\".\" + eval(input()) + \".\")",
"+grid += [\".\" * (w + 2)]",
"+for i in range(1, h + 1):",
"+ for j in range(1, w + 1):",
"+ if grid[i][j] == \"#\":",
"+ if not (",
"+ grid[i][j - 1] == \"#\"",
"+ or grid[i][j + 1] == \"#\"",
"+ or grid[i - 1][j] == \"#\"",
"+ or grid[i + 1][j] == \"#\"",
"+ ):",
"+ print(\"No\")",
"+ exit()",
"+print(\"Yes\")"
] | false | 0.035858 | 0.034027 | 1.053812 | [
"s357749092",
"s016806519"
] |
u537550206 | p03324 | python | s424594570 | s106898258 | 261 | 28 | 3,060 | 9,164 | Accepted | Accepted | 89.27 | d, n = list(map(int, input().split()))
def division(x):
if x % 100 != 0:
return 0
else:
return division(x//100) +1
count= 0
for i in range(1, 1010001):
if division(i) == d:
count +=1
if count == n:
print(i)
break | d, n = list(map(int, input().split()))
if d == 0:
count = 0
for i in range(1, 110):
if i % 100 != 0:
count += 1
if count == n:
print(i)
break
else:
continue
if d == 1:
count = 0
for i in range(100, 20000, 100):
if i % 100 == 0 and i % 10000 != 0:
count+=1
if count == n:
print(i)
break
else:
continue
if d == 2:
count = 0
for i in range(10000, 2000000, 10000):
if i % 10000 == 0 and i % 1000000 != 0:
count+=1
if count == n:
print(i)
break
else:
continue
| 13 | 37 | 274 | 783 | d, n = list(map(int, input().split()))
def division(x):
if x % 100 != 0:
return 0
else:
return division(x // 100) + 1
count = 0
for i in range(1, 1010001):
if division(i) == d:
count += 1
if count == n:
print(i)
break
| d, n = list(map(int, input().split()))
if d == 0:
count = 0
for i in range(1, 110):
if i % 100 != 0:
count += 1
if count == n:
print(i)
break
else:
continue
if d == 1:
count = 0
for i in range(100, 20000, 100):
if i % 100 == 0 and i % 10000 != 0:
count += 1
if count == n:
print(i)
break
else:
continue
if d == 2:
count = 0
for i in range(10000, 2000000, 10000):
if i % 10000 == 0 and i % 1000000 != 0:
count += 1
if count == n:
print(i)
break
else:
continue
| false | 64.864865 | [
"-",
"-",
"-def division(x):",
"- if x % 100 != 0:",
"- return 0",
"- else:",
"- return division(x // 100) + 1",
"-",
"-",
"-count = 0",
"-for i in range(1, 1010001):",
"- if division(i) == d:",
"- count += 1",
"- if count == n:",
"- print(i)",
"- break",
"+if d == 0:",
"+ count = 0",
"+ for i in range(1, 110):",
"+ if i % 100 != 0:",
"+ count += 1",
"+ if count == n:",
"+ print(i)",
"+ break",
"+ else:",
"+ continue",
"+if d == 1:",
"+ count = 0",
"+ for i in range(100, 20000, 100):",
"+ if i % 100 == 0 and i % 10000 != 0:",
"+ count += 1",
"+ if count == n:",
"+ print(i)",
"+ break",
"+ else:",
"+ continue",
"+if d == 2:",
"+ count = 0",
"+ for i in range(10000, 2000000, 10000):",
"+ if i % 10000 == 0 and i % 1000000 != 0:",
"+ count += 1",
"+ if count == n:",
"+ print(i)",
"+ break",
"+ else:",
"+ continue"
] | false | 0.379961 | 0.007486 | 50.759518 | [
"s424594570",
"s106898258"
] |
u498487134 | p02936 | python | s693458927 | s652606703 | 1,297 | 731 | 128,244 | 137,244 | Accepted | Accepted | 43.64 | import queue
import sys
input = sys.stdin.readline
N,Q=list(map(int,input().split()))
c=[0]*N#count
to=[[] for i in range(N)]
for i in range(N-1):
a,b =list(map(int,input().split()))
a-=1
b-=1
to[a].append(b)
to[b].append(a)
for i in range(Q):
p,x =list(map(int,input().split()))
p-=1
c[p]+=x
q=queue.Queue()
q.put((0,-1))
while not q.empty():
v,prev=q.get()
for i in range(len(to[v])):
v_next=to[v][i]
if v_next!=prev:
q.put((v_next,v))
c[v_next]+=c[v]
print((' '.join(map(str, c)))) | import sys
input = sys.stdin.readline
def I(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
def main():
mod=10**9+7
import queue
N,Q=MI()
adj=[[]for _ in range(N)]
for _ in range(N-1):
a,b=MI()
a-=1
b-=1
adj[a].append(b)
adj[b].append(a)
ans=[0]*N
for _ in range(Q):
p,x=MI()
p-=1
ans[p]+=x
q=queue.Queue()
q.put((0,-1))
while not q.empty():
v,p=q.get()
for nv in adj[v]:
if nv!=p:
ans[nv]+=ans[v]
q.put((nv,v))
print((' '.join(map(str, ans))))
main()
| 36 | 40 | 609 | 781 | import queue
import sys
input = sys.stdin.readline
N, Q = list(map(int, input().split()))
c = [0] * N # count
to = [[] for i in range(N)]
for i in range(N - 1):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
to[a].append(b)
to[b].append(a)
for i in range(Q):
p, x = list(map(int, input().split()))
p -= 1
c[p] += x
q = queue.Queue()
q.put((0, -1))
while not q.empty():
v, prev = q.get()
for i in range(len(to[v])):
v_next = to[v][i]
if v_next != prev:
q.put((v_next, v))
c[v_next] += c[v]
print((" ".join(map(str, c))))
| import sys
input = sys.stdin.readline
def I():
return int(eval(input()))
def MI():
return list(map(int, input().split()))
def LI():
return list(map(int, input().split()))
def main():
mod = 10**9 + 7
import queue
N, Q = MI()
adj = [[] for _ in range(N)]
for _ in range(N - 1):
a, b = MI()
a -= 1
b -= 1
adj[a].append(b)
adj[b].append(a)
ans = [0] * N
for _ in range(Q):
p, x = MI()
p -= 1
ans[p] += x
q = queue.Queue()
q.put((0, -1))
while not q.empty():
v, p = q.get()
for nv in adj[v]:
if nv != p:
ans[nv] += ans[v]
q.put((nv, v))
print((" ".join(map(str, ans))))
main()
| false | 10 | [
"-import queue",
"-N, Q = list(map(int, input().split()))",
"-c = [0] * N # count",
"-to = [[] for i in range(N)]",
"-for i in range(N - 1):",
"- a, b = list(map(int, input().split()))",
"- a -= 1",
"- b -= 1",
"- to[a].append(b)",
"- to[b].append(a)",
"-for i in range(Q):",
"- p, x = list(map(int, input().split()))",
"- p -= 1",
"- c[p] += x",
"-q = queue.Queue()",
"-q.put((0, -1))",
"-while not q.empty():",
"- v, prev = q.get()",
"- for i in range(len(to[v])):",
"- v_next = to[v][i]",
"- if v_next != prev:",
"- q.put((v_next, v))",
"- c[v_next] += c[v]",
"-print((\" \".join(map(str, c))))",
"+",
"+",
"+def I():",
"+ return int(eval(input()))",
"+",
"+",
"+def MI():",
"+ return list(map(int, input().split()))",
"+",
"+",
"+def LI():",
"+ return list(map(int, input().split()))",
"+",
"+",
"+def main():",
"+ mod = 10**9 + 7",
"+ import queue",
"+",
"+ N, Q = MI()",
"+ adj = [[] for _ in range(N)]",
"+ for _ in range(N - 1):",
"+ a, b = MI()",
"+ a -= 1",
"+ b -= 1",
"+ adj[a].append(b)",
"+ adj[b].append(a)",
"+ ans = [0] * N",
"+ for _ in range(Q):",
"+ p, x = MI()",
"+ p -= 1",
"+ ans[p] += x",
"+ q = queue.Queue()",
"+ q.put((0, -1))",
"+ while not q.empty():",
"+ v, p = q.get()",
"+ for nv in adj[v]:",
"+ if nv != p:",
"+ ans[nv] += ans[v]",
"+ q.put((nv, v))",
"+ print((\" \".join(map(str, ans))))",
"+",
"+",
"+main()"
] | false | 0.041111 | 0.047398 | 0.867366 | [
"s693458927",
"s652606703"
] |
u497046426 | p02735 | python | s424419119 | s062743437 | 79 | 71 | 7,156 | 7,412 | Accepted | Accepted | 10.13 | from itertools import product
from heapq import heappush, heappop
class Dijkstra:
def __init__(self, N):
self.N = N # #vertices
self.E = [[] for _ in range(N)]
def add_edge(self, init, end, weight, undirected=False):
self.E[init].append((end, weight))
if undirected: self.E[end].append((init, weight))
def distance(self, s):
INF = float('inf')
self.dist = [INF] * self.N # the distance of each vertex from s
self.prev = [-1] * self.N # the previous vertex of each vertex on a shortest path from s
visited = [False] * self.N
n_visited = 0 # #(visited vertices)
heap = []
heappush(heap, (0, -1, s))
while heap:
d, p, v = heappop(heap)
if visited[v]: continue # (s,v)-shortest path is already calculated
self.dist[v] = d; self.prev[v] = p; visited[v] = True
n_visited += 1
if n_visited == self.N: break
for u, c in self.E[v]:
if visited[u]: continue
temp = d + c
if self.dist[u] > temp: heappush(heap, (temp, v, u))
return self.dist
def shortest_path(self, t):
P = []
prev = self.prev
while True:
P.append(t)
t = prev[t]
if t == -1: break
return P[::-1]
H, W = list(map(int, input().split()))
dijkstra = Dijkstra(H * W)
def vtx(i, j): return i*W + j
def coord(n): return divmod(n, W)
grid = [eval(input()) for _ in range(H)] # |string| = W
E = [[] for _ in range(H * W)]
ans = 0 if grid[0][0] == '.' else 1
for i, j in product(list(range(H)), list(range(W))):
v = vtx(i, j)
check = [vtx(i+dx, j+dy) for dx, dy in [(1, 0), (0, 1)] if i+dx <= H-1 and j+dy <= W-1]
for u in check:
x, y = coord(u)
if grid[i][j] == '.' and grid[x][y] == '#':
dijkstra.add_edge(v, u, 1)
else:
dijkstra.add_edge(v, u, 0)
dist = dijkstra.distance(0)
ans += dist[vtx(H-1, W-1)]
print(ans) | from itertools import product
from collections import deque
class ZeroOneBFS:
def __init__(self, N):
self.N = N # #vertices
self.E = [[] for _ in range(N)]
def add_edge(self, init, end, weight, undirected=False):
assert weight in [0, 1]
self.E[init].append((end, weight))
if undirected: self.E[end].append((init, weight))
def distance(self, s):
INF = float('inf')
self.dist = [INF] * self.N # the distance of each vertex from s
self.prev = [-1] * self.N # the previous vertex of each vertex on a shortest path from s
visited = [False] * self.N
dq = deque([(0, -1, s)]) # (dist, prev, vertex)
n_visited = 0 # #(visited vertices)
while dq:
d, p, v = dq.popleft()
if visited[v]: continue # (s,v)-shortest path is already calculated
self.dist[v] = d; self.prev[v] = p; visited[v] = True
n_visited += 1
if n_visited == self.N: break
for u, c in self.E[v]:
if visited[u]: continue
if c == 0: dq.appendleft((d, v, u))
else: dq.append((d + 1, v, u))
return self.dist
def shortest_path(self, t):
P = []
prev = self.prev
while True:
P.append(t)
t = prev[t]
if t == -1: break
return P[::-1]
H, W = list(map(int, input().split()))
zobfs = ZeroOneBFS(H * W)
def vtx(i, j): return i*W + j
def coord(n): return divmod(n, W)
grid = [eval(input()) for _ in range(H)] # |string| = W
E = [[] for _ in range(H * W)]
ans = 0 if grid[0][0] == '.' else 1
for i, j in product(list(range(H)), list(range(W))):
v = vtx(i, j)
check = [vtx(i+dx, j+dy) for dx, dy in [(1, 0), (0, 1)] if i+dx <= H-1 and j+dy <= W-1]
for u in check:
x, y = coord(u)
if grid[i][j] == '.' and grid[x][y] == '#':
zobfs.add_edge(v, u, 1)
else:
zobfs.add_edge(v, u, 0)
dist = zobfs.distance(0)
ans += dist[vtx(H-1, W-1)]
print(ans) | 62 | 62 | 2,080 | 2,113 | from itertools import product
from heapq import heappush, heappop
class Dijkstra:
def __init__(self, N):
self.N = N # #vertices
self.E = [[] for _ in range(N)]
def add_edge(self, init, end, weight, undirected=False):
self.E[init].append((end, weight))
if undirected:
self.E[end].append((init, weight))
def distance(self, s):
INF = float("inf")
self.dist = [INF] * self.N # the distance of each vertex from s
self.prev = [
-1
] * self.N # the previous vertex of each vertex on a shortest path from s
visited = [False] * self.N
n_visited = 0 # #(visited vertices)
heap = []
heappush(heap, (0, -1, s))
while heap:
d, p, v = heappop(heap)
if visited[v]:
continue # (s,v)-shortest path is already calculated
self.dist[v] = d
self.prev[v] = p
visited[v] = True
n_visited += 1
if n_visited == self.N:
break
for u, c in self.E[v]:
if visited[u]:
continue
temp = d + c
if self.dist[u] > temp:
heappush(heap, (temp, v, u))
return self.dist
def shortest_path(self, t):
P = []
prev = self.prev
while True:
P.append(t)
t = prev[t]
if t == -1:
break
return P[::-1]
H, W = list(map(int, input().split()))
dijkstra = Dijkstra(H * W)
def vtx(i, j):
return i * W + j
def coord(n):
return divmod(n, W)
grid = [eval(input()) for _ in range(H)] # |string| = W
E = [[] for _ in range(H * W)]
ans = 0 if grid[0][0] == "." else 1
for i, j in product(list(range(H)), list(range(W))):
v = vtx(i, j)
check = [
vtx(i + dx, j + dy)
for dx, dy in [(1, 0), (0, 1)]
if i + dx <= H - 1 and j + dy <= W - 1
]
for u in check:
x, y = coord(u)
if grid[i][j] == "." and grid[x][y] == "#":
dijkstra.add_edge(v, u, 1)
else:
dijkstra.add_edge(v, u, 0)
dist = dijkstra.distance(0)
ans += dist[vtx(H - 1, W - 1)]
print(ans)
| from itertools import product
from collections import deque
class ZeroOneBFS:
def __init__(self, N):
self.N = N # #vertices
self.E = [[] for _ in range(N)]
def add_edge(self, init, end, weight, undirected=False):
assert weight in [0, 1]
self.E[init].append((end, weight))
if undirected:
self.E[end].append((init, weight))
def distance(self, s):
INF = float("inf")
self.dist = [INF] * self.N # the distance of each vertex from s
self.prev = [
-1
] * self.N # the previous vertex of each vertex on a shortest path from s
visited = [False] * self.N
dq = deque([(0, -1, s)]) # (dist, prev, vertex)
n_visited = 0 # #(visited vertices)
while dq:
d, p, v = dq.popleft()
if visited[v]:
continue # (s,v)-shortest path is already calculated
self.dist[v] = d
self.prev[v] = p
visited[v] = True
n_visited += 1
if n_visited == self.N:
break
for u, c in self.E[v]:
if visited[u]:
continue
if c == 0:
dq.appendleft((d, v, u))
else:
dq.append((d + 1, v, u))
return self.dist
def shortest_path(self, t):
P = []
prev = self.prev
while True:
P.append(t)
t = prev[t]
if t == -1:
break
return P[::-1]
H, W = list(map(int, input().split()))
zobfs = ZeroOneBFS(H * W)
def vtx(i, j):
return i * W + j
def coord(n):
return divmod(n, W)
grid = [eval(input()) for _ in range(H)] # |string| = W
E = [[] for _ in range(H * W)]
ans = 0 if grid[0][0] == "." else 1
for i, j in product(list(range(H)), list(range(W))):
v = vtx(i, j)
check = [
vtx(i + dx, j + dy)
for dx, dy in [(1, 0), (0, 1)]
if i + dx <= H - 1 and j + dy <= W - 1
]
for u in check:
x, y = coord(u)
if grid[i][j] == "." and grid[x][y] == "#":
zobfs.add_edge(v, u, 1)
else:
zobfs.add_edge(v, u, 0)
dist = zobfs.distance(0)
ans += dist[vtx(H - 1, W - 1)]
print(ans)
| false | 0 | [
"-from heapq import heappush, heappop",
"+from collections import deque",
"-class Dijkstra:",
"+class ZeroOneBFS:",
"+ assert weight in [0, 1]",
"+ dq = deque([(0, -1, s)]) # (dist, prev, vertex)",
"- heap = []",
"- heappush(heap, (0, -1, s))",
"- while heap:",
"- d, p, v = heappop(heap)",
"+ while dq:",
"+ d, p, v = dq.popleft()",
"- temp = d + c",
"- if self.dist[u] > temp:",
"- heappush(heap, (temp, v, u))",
"+ if c == 0:",
"+ dq.appendleft((d, v, u))",
"+ else:",
"+ dq.append((d + 1, v, u))",
"-dijkstra = Dijkstra(H * W)",
"+zobfs = ZeroOneBFS(H * W)",
"- dijkstra.add_edge(v, u, 1)",
"+ zobfs.add_edge(v, u, 1)",
"- dijkstra.add_edge(v, u, 0)",
"-dist = dijkstra.distance(0)",
"+ zobfs.add_edge(v, u, 0)",
"+dist = zobfs.distance(0)"
] | false | 0.007805 | 0.088409 | 0.088286 | [
"s424419119",
"s062743437"
] |
u449580152 | p02689 | python | s633977312 | s232289075 | 413 | 379 | 25,968 | 26,048 | Accepted | Accepted | 8.23 | n, m = list(map(int, input().split()))
h = list(map(int, input().split()))
sore = [[0] for i in range(n)]
for i in range(m):
road = list(map(int, input().split()))
sore[road[0]-1].append(h[road[1]-1])
sore[road[1]-1].append(h[road[0]-1])
ans = 0
for i in range(n):
if h[i] > max(sore[i]):
ans+=1
print(ans) | n,m = list(map(int, input().split()))
H = list(map(int, input().split()))
s = [[0] for i in range(n)]
for i in range(m):
a, b = list(map(int, input().split()))
s[a-1].append(H[b-1])
s[b-1].append(H[a-1])
c = 0
for j in range(n):
if H[j] > max(s[j]):
c+= 1
print(c) | 12 | 12 | 335 | 288 | n, m = list(map(int, input().split()))
h = list(map(int, input().split()))
sore = [[0] for i in range(n)]
for i in range(m):
road = list(map(int, input().split()))
sore[road[0] - 1].append(h[road[1] - 1])
sore[road[1] - 1].append(h[road[0] - 1])
ans = 0
for i in range(n):
if h[i] > max(sore[i]):
ans += 1
print(ans)
| n, m = list(map(int, input().split()))
H = list(map(int, input().split()))
s = [[0] for i in range(n)]
for i in range(m):
a, b = list(map(int, input().split()))
s[a - 1].append(H[b - 1])
s[b - 1].append(H[a - 1])
c = 0
for j in range(n):
if H[j] > max(s[j]):
c += 1
print(c)
| false | 0 | [
"-h = list(map(int, input().split()))",
"-sore = [[0] for i in range(n)]",
"+H = list(map(int, input().split()))",
"+s = [[0] for i in range(n)]",
"- road = list(map(int, input().split()))",
"- sore[road[0] - 1].append(h[road[1] - 1])",
"- sore[road[1] - 1].append(h[road[0] - 1])",
"-ans = 0",
"-for i in range(n):",
"- if h[i] > max(sore[i]):",
"- ans += 1",
"-print(ans)",
"+ a, b = list(map(int, input().split()))",
"+ s[a - 1].append(H[b - 1])",
"+ s[b - 1].append(H[a - 1])",
"+c = 0",
"+for j in range(n):",
"+ if H[j] > max(s[j]):",
"+ c += 1",
"+print(c)"
] | false | 0.035337 | 0.032511 | 1.086937 | [
"s633977312",
"s232289075"
] |
u201928947 | p03061 | python | s007221370 | s007144134 | 370 | 203 | 105,696 | 16,120 | Accepted | Accepted | 45.14 | from fractions import gcd
n = int(eval(input()))
a = list(map(int,input().split()))
GCD= a[0]
dp = [set() for i in range(n)]
dp[1].add(a[0])
dp[1].add(a[1])
for i in range(1,n):
x = a[i]
for j in dp[i-1]:
dp[i].add(gcd(j,x))
if x % GCD != 0:
dp[i].add(GCD)
GCD = gcd(GCD,x)
print((max(dp[n-1]))) | from fractions import gcd
n = int(eval(input()))
a = list(map(int,input().split()))
left = []
right = []
left.append(a[0])
for i in range(1,n-1):
left.append(gcd(left[-1],a[i]))
a = a[::-1]
right.append(a[0])
for i in range(1,n-1):
right.append(gcd(right[-1],a[i]))
ans = 1
for i in range(n-1):
ans = max(ans,gcd(left[i],right[n-i-3]))
ans = max(ans,left[n-2],right[n-2])
print(ans)
| 15 | 18 | 341 | 407 | from fractions import gcd
n = int(eval(input()))
a = list(map(int, input().split()))
GCD = a[0]
dp = [set() for i in range(n)]
dp[1].add(a[0])
dp[1].add(a[1])
for i in range(1, n):
x = a[i]
for j in dp[i - 1]:
dp[i].add(gcd(j, x))
if x % GCD != 0:
dp[i].add(GCD)
GCD = gcd(GCD, x)
print((max(dp[n - 1])))
| from fractions import gcd
n = int(eval(input()))
a = list(map(int, input().split()))
left = []
right = []
left.append(a[0])
for i in range(1, n - 1):
left.append(gcd(left[-1], a[i]))
a = a[::-1]
right.append(a[0])
for i in range(1, n - 1):
right.append(gcd(right[-1], a[i]))
ans = 1
for i in range(n - 1):
ans = max(ans, gcd(left[i], right[n - i - 3]))
ans = max(ans, left[n - 2], right[n - 2])
print(ans)
| false | 16.666667 | [
"-GCD = a[0]",
"-dp = [set() for i in range(n)]",
"-dp[1].add(a[0])",
"-dp[1].add(a[1])",
"-for i in range(1, n):",
"- x = a[i]",
"- for j in dp[i - 1]:",
"- dp[i].add(gcd(j, x))",
"- if x % GCD != 0:",
"- dp[i].add(GCD)",
"- GCD = gcd(GCD, x)",
"-print((max(dp[n - 1])))",
"+left = []",
"+right = []",
"+left.append(a[0])",
"+for i in range(1, n - 1):",
"+ left.append(gcd(left[-1], a[i]))",
"+a = a[::-1]",
"+right.append(a[0])",
"+for i in range(1, n - 1):",
"+ right.append(gcd(right[-1], a[i]))",
"+ans = 1",
"+for i in range(n - 1):",
"+ ans = max(ans, gcd(left[i], right[n - i - 3]))",
"+ans = max(ans, left[n - 2], right[n - 2])",
"+print(ans)"
] | false | 0.04953 | 0.108064 | 0.458335 | [
"s007221370",
"s007144134"
] |
u903948194 | p03290 | python | s643178809 | s512461322 | 53 | 49 | 9,240 | 9,104 | Accepted | Accepted | 7.55 | D, G = [int(n) for n in input().split()]
score_table = []
for i in range(1, D+1):
p, c = [int(n) for n in input().split()]
score_table.append([i*100, p, c])
min_count = sum([l[1] for l in score_table])
#print(min_count)
for bit in range(1<<D):
score = 0
count = 0
for i in range(D):
if bit & (1<<i):
score += score_table[i][0] * score_table[i][1] + score_table[i][2]
count += score_table[i][1]
if score >= G:
min_count = min(min_count, count)
else:
additional = []
for j in range(D):
if not bit & (1<<j):
additional.append(score_table[j])
additional_ = sorted(additional, key=lambda x:x[0], reverse=True)
#print(additional_)
# for i in additional_:
# if i[1] > 1:
# add_score = i
# break
add_score = additional_[0]
for k in range(add_score[1]-1):
score += add_score[0]
count += 1
if score >= G:
min_count = min(min_count, count)
print(min_count) | D, G = [int(n) for n in input().split()]
score_table = []
for i in range(1, D+1):
p, c = [int(n) for n in input().split()]
score_table.append([i*100, p, c])
min_count = sum([l[1] for l in score_table])
#print(min_count)
for bit in range(1<<D):
score = 0
count = 0
for i in range(D):
if bit & (1<<i):
score += score_table[i][0] * score_table[i][1] + score_table[i][2]
count += score_table[i][1]
if score >= G:
min_count = min(min_count, count)
else:
additional = []
for j in range(D):
if not bit & (1<<j):
additional.append(score_table[j])
additional_ = sorted(additional, key=lambda x:x[0], reverse=True)
#print(additional_)
# for i in additional_:
# if i[1] > 1:
# add_score = i
# break
#add_score = additional_[0]
for k in range(additional_[0][1]-1):
score += additional_[0][0]
count += 1
if score >= G:
min_count = min(min_count, count)
print(min_count) | 44 | 44 | 1,166 | 1,177 | D, G = [int(n) for n in input().split()]
score_table = []
for i in range(1, D + 1):
p, c = [int(n) for n in input().split()]
score_table.append([i * 100, p, c])
min_count = sum([l[1] for l in score_table])
# print(min_count)
for bit in range(1 << D):
score = 0
count = 0
for i in range(D):
if bit & (1 << i):
score += score_table[i][0] * score_table[i][1] + score_table[i][2]
count += score_table[i][1]
if score >= G:
min_count = min(min_count, count)
else:
additional = []
for j in range(D):
if not bit & (1 << j):
additional.append(score_table[j])
additional_ = sorted(additional, key=lambda x: x[0], reverse=True)
# print(additional_)
# for i in additional_:
# if i[1] > 1:
# add_score = i
# break
add_score = additional_[0]
for k in range(add_score[1] - 1):
score += add_score[0]
count += 1
if score >= G:
min_count = min(min_count, count)
print(min_count)
| D, G = [int(n) for n in input().split()]
score_table = []
for i in range(1, D + 1):
p, c = [int(n) for n in input().split()]
score_table.append([i * 100, p, c])
min_count = sum([l[1] for l in score_table])
# print(min_count)
for bit in range(1 << D):
score = 0
count = 0
for i in range(D):
if bit & (1 << i):
score += score_table[i][0] * score_table[i][1] + score_table[i][2]
count += score_table[i][1]
if score >= G:
min_count = min(min_count, count)
else:
additional = []
for j in range(D):
if not bit & (1 << j):
additional.append(score_table[j])
additional_ = sorted(additional, key=lambda x: x[0], reverse=True)
# print(additional_)
# for i in additional_:
# if i[1] > 1:
# add_score = i
# break
# add_score = additional_[0]
for k in range(additional_[0][1] - 1):
score += additional_[0][0]
count += 1
if score >= G:
min_count = min(min_count, count)
print(min_count)
| false | 0 | [
"- add_score = additional_[0]",
"- for k in range(add_score[1] - 1):",
"- score += add_score[0]",
"+ # add_score = additional_[0]",
"+ for k in range(additional_[0][1] - 1):",
"+ score += additional_[0][0]"
] | false | 0.037141 | 0.037857 | 0.981098 | [
"s643178809",
"s512461322"
] |
u179169725 | p03372 | python | s268982884 | s046551160 | 496 | 428 | 39,588 | 92,380 | Accepted | Accepted | 13.71 | # https://atcoder.jp/contests/abc095/tasks/arc096_b
# 写真参考
import sys
read = sys.stdin.readline
ra = range
enu = enumerate
def read_ints():
return list(map(int, read().split()))
def read_col(H):
'''
H is number of rows
A列、B列が与えられるようなとき
ex1)A,B=read_col(H) ex2) A,=read_col(H) #一列の場合
'''
ret = []
for _ in range(H):
ret.append(list(map(int, read().split())))
return tuple(map(list, list(zip(*ret))))
MOD = 10**9 + 7
INF = 2**31 # 2147483648 > 10**9
# default import
from collections import defaultdict, Counter, deque
from operator import itemgetter
from itertools import product, permutations, combinations, accumulate
from bisect import bisect_left, bisect_right # , insort_left, insort_right
N, C = read_ints()
X, V = read_col(N)
def solve_max_a_plas_b(A: list, B: list):
'''max_{i<j}(a_i + b_j)をO(n)で解く'''
assert len(A) == len(B)
A_accum = list(accumulate(A, func=max))
B_accum = list(accumulate(reversed(B), func=max))[::-1]
ret = 0
for i in range(len(A_accum) - 1):
ret = max(A_accum[i] + B_accum[i + 1], ret)
return ret
def ret_candi(X, V):
V_accum = list(accumulate(V))
V_accum_r = list(accumulate(reversed(V)))[::-1]
A, B = [], []
katamiti_max = 0 # 必ず折れ曲がるとも限らないので
for i in range(N):
katamiti_max = max(katamiti_max, V_accum[i] - X[i])
A.append(V_accum[i] - 2 * X[i])
B.append((V_accum_r[i]) - (C - X[i]))
# print(A, B)
return A, B, katamiti_max
def solve(X, V):
A, B, katamiti_max = ret_candi(X, V)
return max(solve_max_a_plas_b(A, B), katamiti_max)
V_r = V[::-1]
X_r = []
for x in reversed(X):
X_r.append(C - x)
print((max(solve(X, V), solve(X_r, V_r))))
| import sys
sys.setrecursionlimit(1 << 25)
read = sys.stdin.readline
ra = range
enu = enumerate
def read_ints():
return list(map(int, read().split()))
def read_a_int():
return int(read())
def read_tuple(H):
'''
H is number of rows
'''
ret = []
for _ in range(H):
ret.append(tuple(map(int, read().split())))
return ret
def read_col(H):
'''
H is number of rows
A列、B列が与えられるようなとき
ex1)A,B=read_col(H) ex2) A,=read_col(H) #一列の場合
'''
ret = []
for _ in range(H):
ret.append(list(map(int, read().split())))
return tuple(map(list, list(zip(*ret))))
def read_matrix(H):
'''
H is number of rows
'''
ret = []
for _ in range(H):
ret.append(list(map(int, read().split())))
return ret
# return [list(map(int, read().split())) for _ in range(H)] # 内包表記はpypyでは遅いため
MOD = 10**9 + 7
INF = 2**31 # 2147483648 > 10**9
# default import
from collections import defaultdict, Counter, deque
from operator import itemgetter
from itertools import product, permutations, combinations
from bisect import bisect_left, bisect_right # , insort_left, insort_right
# https://atcoder.jp/contests/abc095/tasks/arc096_b
N, C = read_ints()
X, V = read_col(N)
# 遠くの寿司も見ないとダメそう(vがバカでかい可能性がある)
# とりあえず右スタートを前提に考える。歩く距離の最小は2パターン。
# 1. 右に進んで食べるだけ
# 2. 途中まで右に進んで途中で左に戻る
def ret_ans1(X, V): # 右スタート想定
sum_v = 0
ans = -1
for x, v in zip(X, V):
sum_v += v
ans = max(ans, sum_v - x)
return ans
def ret_ans2(X, V): # ただし右スタートを想定
Z = []
sum_v = 0
for x, v in zip(X, V):
sum_v += v
Z.append(sum_v - 2 * x)
Y = []
sum_v = 0
for x, v in reversed(list(zip(X, V))):
sum_v += v
Y.append(sum_v - (C - x))
Y = list(reversed(Y))
# optimize
ans = max_sum(Z, Y)
return ans
def max_sum(X, Y):
# X_i + Y_j (i<j)を最大化する O(n)
X_accum = [-10**15]
for x in X:
X_accum.append(max(x, X_accum[-1]))
del X_accum[0]
Y_accum = [-10**15]
for y in reversed(Y):
Y_accum.append(max(y, Y_accum[-1]))
Y_accum = list(reversed(Y_accum))
del Y_accum[-1]
ret = 0
for i in range(len(X) - 1):
ret = max(ret, X_accum[i] + Y_accum[i + 1])
return ret
ans = 0
ans = max(ans, ret_ans1(X, V))
ans = max(ans, ret_ans2(X, V))
# 左周りにスタートする
V = list(reversed(V))
X_r = []
for x in reversed(X):
X_r.append(C - x)
ans = max(ans, ret_ans1(X_r, V))
ans = max(ans, ret_ans2(X_r, V))
print(ans)
| 73 | 125 | 1,798 | 2,635 | # https://atcoder.jp/contests/abc095/tasks/arc096_b
# 写真参考
import sys
read = sys.stdin.readline
ra = range
enu = enumerate
def read_ints():
return list(map(int, read().split()))
def read_col(H):
"""
H is number of rows
A列、B列が与えられるようなとき
ex1)A,B=read_col(H) ex2) A,=read_col(H) #一列の場合
"""
ret = []
for _ in range(H):
ret.append(list(map(int, read().split())))
return tuple(map(list, list(zip(*ret))))
MOD = 10**9 + 7
INF = 2**31 # 2147483648 > 10**9
# default import
from collections import defaultdict, Counter, deque
from operator import itemgetter
from itertools import product, permutations, combinations, accumulate
from bisect import bisect_left, bisect_right # , insort_left, insort_right
N, C = read_ints()
X, V = read_col(N)
def solve_max_a_plas_b(A: list, B: list):
"""max_{i<j}(a_i + b_j)をO(n)で解く"""
assert len(A) == len(B)
A_accum = list(accumulate(A, func=max))
B_accum = list(accumulate(reversed(B), func=max))[::-1]
ret = 0
for i in range(len(A_accum) - 1):
ret = max(A_accum[i] + B_accum[i + 1], ret)
return ret
def ret_candi(X, V):
V_accum = list(accumulate(V))
V_accum_r = list(accumulate(reversed(V)))[::-1]
A, B = [], []
katamiti_max = 0 # 必ず折れ曲がるとも限らないので
for i in range(N):
katamiti_max = max(katamiti_max, V_accum[i] - X[i])
A.append(V_accum[i] - 2 * X[i])
B.append((V_accum_r[i]) - (C - X[i]))
# print(A, B)
return A, B, katamiti_max
def solve(X, V):
A, B, katamiti_max = ret_candi(X, V)
return max(solve_max_a_plas_b(A, B), katamiti_max)
V_r = V[::-1]
X_r = []
for x in reversed(X):
X_r.append(C - x)
print((max(solve(X, V), solve(X_r, V_r))))
| import sys
sys.setrecursionlimit(1 << 25)
read = sys.stdin.readline
ra = range
enu = enumerate
def read_ints():
return list(map(int, read().split()))
def read_a_int():
return int(read())
def read_tuple(H):
"""
H is number of rows
"""
ret = []
for _ in range(H):
ret.append(tuple(map(int, read().split())))
return ret
def read_col(H):
"""
H is number of rows
A列、B列が与えられるようなとき
ex1)A,B=read_col(H) ex2) A,=read_col(H) #一列の場合
"""
ret = []
for _ in range(H):
ret.append(list(map(int, read().split())))
return tuple(map(list, list(zip(*ret))))
def read_matrix(H):
"""
H is number of rows
"""
ret = []
for _ in range(H):
ret.append(list(map(int, read().split())))
return ret
# return [list(map(int, read().split())) for _ in range(H)] # 内包表記はpypyでは遅いため
MOD = 10**9 + 7
INF = 2**31 # 2147483648 > 10**9
# default import
from collections import defaultdict, Counter, deque
from operator import itemgetter
from itertools import product, permutations, combinations
from bisect import bisect_left, bisect_right # , insort_left, insort_right
# https://atcoder.jp/contests/abc095/tasks/arc096_b
N, C = read_ints()
X, V = read_col(N)
# 遠くの寿司も見ないとダメそう(vがバカでかい可能性がある)
# とりあえず右スタートを前提に考える。歩く距離の最小は2パターン。
# 1. 右に進んで食べるだけ
# 2. 途中まで右に進んで途中で左に戻る
def ret_ans1(X, V): # 右スタート想定
sum_v = 0
ans = -1
for x, v in zip(X, V):
sum_v += v
ans = max(ans, sum_v - x)
return ans
def ret_ans2(X, V): # ただし右スタートを想定
Z = []
sum_v = 0
for x, v in zip(X, V):
sum_v += v
Z.append(sum_v - 2 * x)
Y = []
sum_v = 0
for x, v in reversed(list(zip(X, V))):
sum_v += v
Y.append(sum_v - (C - x))
Y = list(reversed(Y))
# optimize
ans = max_sum(Z, Y)
return ans
def max_sum(X, Y):
# X_i + Y_j (i<j)を最大化する O(n)
X_accum = [-(10**15)]
for x in X:
X_accum.append(max(x, X_accum[-1]))
del X_accum[0]
Y_accum = [-(10**15)]
for y in reversed(Y):
Y_accum.append(max(y, Y_accum[-1]))
Y_accum = list(reversed(Y_accum))
del Y_accum[-1]
ret = 0
for i in range(len(X) - 1):
ret = max(ret, X_accum[i] + Y_accum[i + 1])
return ret
ans = 0
ans = max(ans, ret_ans1(X, V))
ans = max(ans, ret_ans2(X, V))
# 左周りにスタートする
V = list(reversed(V))
X_r = []
for x in reversed(X):
X_r.append(C - x)
ans = max(ans, ret_ans1(X_r, V))
ans = max(ans, ret_ans2(X_r, V))
print(ans)
| false | 41.6 | [
"-# https://atcoder.jp/contests/abc095/tasks/arc096_b",
"-# 写真参考",
"+sys.setrecursionlimit(1 << 25)",
"+",
"+",
"+def read_a_int():",
"+ return int(read())",
"+",
"+",
"+def read_tuple(H):",
"+ \"\"\"",
"+ H is number of rows",
"+ \"\"\"",
"+ ret = []",
"+ for _ in range(H):",
"+ ret.append(tuple(map(int, read().split())))",
"+ return ret",
"+def read_matrix(H):",
"+ \"\"\"",
"+ H is number of rows",
"+ \"\"\"",
"+ ret = []",
"+ for _ in range(H):",
"+ ret.append(list(map(int, read().split())))",
"+ return ret",
"+ # return [list(map(int, read().split())) for _ in range(H)] # 内包表記はpypyでは遅いため",
"+",
"+",
"-from itertools import product, permutations, combinations, accumulate",
"+from itertools import product, permutations, combinations",
"+# https://atcoder.jp/contests/abc095/tasks/arc096_b",
"+# 遠くの寿司も見ないとダメそう(vがバカでかい可能性がある)",
"+# とりあえず右スタートを前提に考える。歩く距離の最小は2パターン。",
"+# 1. 右に進んで食べるだけ",
"+# 2. 途中まで右に進んで途中で左に戻る",
"+def ret_ans1(X, V): # 右スタート想定",
"+ sum_v = 0",
"+ ans = -1",
"+ for x, v in zip(X, V):",
"+ sum_v += v",
"+ ans = max(ans, sum_v - x)",
"+ return ans",
"-def solve_max_a_plas_b(A: list, B: list):",
"- \"\"\"max_{i<j}(a_i + b_j)をO(n)で解く\"\"\"",
"- assert len(A) == len(B)",
"- A_accum = list(accumulate(A, func=max))",
"- B_accum = list(accumulate(reversed(B), func=max))[::-1]",
"+def ret_ans2(X, V): # ただし右スタートを想定",
"+ Z = []",
"+ sum_v = 0",
"+ for x, v in zip(X, V):",
"+ sum_v += v",
"+ Z.append(sum_v - 2 * x)",
"+ Y = []",
"+ sum_v = 0",
"+ for x, v in reversed(list(zip(X, V))):",
"+ sum_v += v",
"+ Y.append(sum_v - (C - x))",
"+ Y = list(reversed(Y))",
"+ # optimize",
"+ ans = max_sum(Z, Y)",
"+ return ans",
"+",
"+",
"+def max_sum(X, Y):",
"+ # X_i + Y_j (i<j)を最大化する O(n)",
"+ X_accum = [-(10**15)]",
"+ for x in X:",
"+ X_accum.append(max(x, X_accum[-1]))",
"+ del X_accum[0]",
"+ Y_accum = [-(10**15)]",
"+ for y in reversed(Y):",
"+ Y_accum.append(max(y, Y_accum[-1]))",
"+ Y_accum = list(reversed(Y_accum))",
"+ del Y_accum[-1]",
"- for i in range(len(A_accum) - 1):",
"- ret = max(A_accum[i] + B_accum[i + 1], ret)",
"+ for i in range(len(X) - 1):",
"+ ret = max(ret, X_accum[i] + Y_accum[i + 1])",
"-def ret_candi(X, V):",
"- V_accum = list(accumulate(V))",
"- V_accum_r = list(accumulate(reversed(V)))[::-1]",
"- A, B = [], []",
"- katamiti_max = 0 # 必ず折れ曲がるとも限らないので",
"- for i in range(N):",
"- katamiti_max = max(katamiti_max, V_accum[i] - X[i])",
"- A.append(V_accum[i] - 2 * X[i])",
"- B.append((V_accum_r[i]) - (C - X[i]))",
"- # print(A, B)",
"- return A, B, katamiti_max",
"-",
"-",
"-def solve(X, V):",
"- A, B, katamiti_max = ret_candi(X, V)",
"- return max(solve_max_a_plas_b(A, B), katamiti_max)",
"-",
"-",
"-V_r = V[::-1]",
"+ans = 0",
"+ans = max(ans, ret_ans1(X, V))",
"+ans = max(ans, ret_ans2(X, V))",
"+# 左周りにスタートする",
"+V = list(reversed(V))",
"-print((max(solve(X, V), solve(X_r, V_r))))",
"+ans = max(ans, ret_ans1(X_r, V))",
"+ans = max(ans, ret_ans2(X_r, V))",
"+print(ans)"
] | false | 0.044854 | 0.125968 | 0.356072 | [
"s268982884",
"s046551160"
] |
u077291787 | p02787 | python | s023045190 | s946141479 | 603 | 307 | 44,548 | 40,560 | Accepted | Accepted | 49.09 | # E - Crested Ibis vs Monster
from collections import defaultdict
def main():
H, N, *AB = list(map(int, open(0).read().split()))
dp = defaultdict(lambda: 1 << 30) # dp[i] := min magic points to decrease monster's health by i
dp[0] = 0
for i in range(H):
if i not in dp:
continue
for a, b in zip(*[iter(AB)] * 2):
if i + a < H:
dp[i + a] = min(dp[i + a], dp[i] + b)
else:
dp[H] = min(dp[H], dp[i] + b)
print((dp[H]))
if __name__ == "__main__":
main()
| # E - Crested Ibis vs Monster
def main():
INF = 1 << 30
H, N, *AB = list(map(int, open(0).read().split()))
dp = [INF] * (H + 1) # dp[i] := min magic points to decrease monster's health by i
dp[0] = 0
for i in range(H):
if dp[i] == INF:
continue
for a, b in zip(*[iter(AB)] * 2):
if i + a < H:
dp[i + a] = min(dp[i + a], dp[i] + b)
else:
dp[H] = min(dp[H], dp[i] + b)
print((dp[H]))
if __name__ == "__main__":
main()
| 21 | 20 | 575 | 547 | # E - Crested Ibis vs Monster
from collections import defaultdict
def main():
H, N, *AB = list(map(int, open(0).read().split()))
dp = defaultdict(
lambda: 1 << 30
) # dp[i] := min magic points to decrease monster's health by i
dp[0] = 0
for i in range(H):
if i not in dp:
continue
for a, b in zip(*[iter(AB)] * 2):
if i + a < H:
dp[i + a] = min(dp[i + a], dp[i] + b)
else:
dp[H] = min(dp[H], dp[i] + b)
print((dp[H]))
if __name__ == "__main__":
main()
| # E - Crested Ibis vs Monster
def main():
INF = 1 << 30
H, N, *AB = list(map(int, open(0).read().split()))
dp = [INF] * (H + 1) # dp[i] := min magic points to decrease monster's health by i
dp[0] = 0
for i in range(H):
if dp[i] == INF:
continue
for a, b in zip(*[iter(AB)] * 2):
if i + a < H:
dp[i + a] = min(dp[i + a], dp[i] + b)
else:
dp[H] = min(dp[H], dp[i] + b)
print((dp[H]))
if __name__ == "__main__":
main()
| false | 4.761905 | [
"-from collections import defaultdict",
"-",
"-",
"+ INF = 1 << 30",
"- dp = defaultdict(",
"- lambda: 1 << 30",
"- ) # dp[i] := min magic points to decrease monster's health by i",
"+ dp = [INF] * (H + 1) # dp[i] := min magic points to decrease monster's health by i",
"- if i not in dp:",
"+ if dp[i] == INF:"
] | false | 0.178528 | 0.091819 | 1.944336 | [
"s023045190",
"s946141479"
] |
u627803856 | p02947 | python | s706948131 | s197464037 | 783 | 424 | 132,608 | 17,808 | Accepted | Accepted | 45.85 | import collections
n=int(eval(input()))
s=[(eval(input())) for _ in range(n)]
lis=[list(s[i]) for i in range(n)]
lis_sort = [sorted(lis[i]) for i in range(n)]
lis_sort = [''.join(lis_sort[i]) for i in range(n)]
lis_sort.sort()
c = collections.Counter(lis_sort)
values, counts = list(zip(*c.most_common(len(c))))
cnt=0
for i in range(len(counts)):
if counts[i]==2: cnt+=1
elif counts[i]>2: cnt+=counts[i]*(counts[i]-1)//2
print(cnt) | n = int(eval(input()))
d = {}
for i in range(n):
s = sorted(list(eval(input())))
s = ''.join(s)
d[s] = d.get(s, 0) + 1
cnt = 0
for k,v in list(d.items()):
if v >= 2:
cnt += v * (v - 1) // 2 # 組の個数
print(cnt) | 17 | 13 | 440 | 230 | import collections
n = int(eval(input()))
s = [(eval(input())) for _ in range(n)]
lis = [list(s[i]) for i in range(n)]
lis_sort = [sorted(lis[i]) for i in range(n)]
lis_sort = ["".join(lis_sort[i]) for i in range(n)]
lis_sort.sort()
c = collections.Counter(lis_sort)
values, counts = list(zip(*c.most_common(len(c))))
cnt = 0
for i in range(len(counts)):
if counts[i] == 2:
cnt += 1
elif counts[i] > 2:
cnt += counts[i] * (counts[i] - 1) // 2
print(cnt)
| n = int(eval(input()))
d = {}
for i in range(n):
s = sorted(list(eval(input())))
s = "".join(s)
d[s] = d.get(s, 0) + 1
cnt = 0
for k, v in list(d.items()):
if v >= 2:
cnt += v * (v - 1) // 2 # 組の個数
print(cnt)
| false | 23.529412 | [
"-import collections",
"-",
"-s = [(eval(input())) for _ in range(n)]",
"-lis = [list(s[i]) for i in range(n)]",
"-lis_sort = [sorted(lis[i]) for i in range(n)]",
"-lis_sort = [\"\".join(lis_sort[i]) for i in range(n)]",
"-lis_sort.sort()",
"-c = collections.Counter(lis_sort)",
"-values, counts = list(zip(*c.most_common(len(c))))",
"+d = {}",
"+for i in range(n):",
"+ s = sorted(list(eval(input())))",
"+ s = \"\".join(s)",
"+ d[s] = d.get(s, 0) + 1",
"-for i in range(len(counts)):",
"- if counts[i] == 2:",
"- cnt += 1",
"- elif counts[i] > 2:",
"- cnt += counts[i] * (counts[i] - 1) // 2",
"+for k, v in list(d.items()):",
"+ if v >= 2:",
"+ cnt += v * (v - 1) // 2 # 組の個数"
] | false | 0.077417 | 0.044959 | 1.721963 | [
"s706948131",
"s197464037"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.