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