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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
u391589398
|
p03290
|
python
|
s479686717
|
s035417406
| 223
| 25
| 43,500
| 3,064
|
Accepted
|
Accepted
| 88.79
|
D, G = list(map(int, input().split()))
G = G // 100
P = []
C = []
for i in range(1, D+1):
p, c = list(map(int, input().split()))
P.append(p)
C.append(c//100)
minnum = 1e9
for i in range(0, 2**D):
total = 0
num = 0
serach0 = [0] * D
for j in range(D):
if (i >> j) & 1:
total += P[j]*(j+1) + C[j]
num += P[j]
serach0[j] = 1
if total >= G:
minnum = min(minnum, num)
continue
while 0 in serach0:
idx = serach0.index(0)
total_ = total
num_ = num
for _ in range(P[idx]):
total_ += idx+1
num_ += 1
if total_ >= G:
minnum = min(minnum, num_)
break
serach0[idx] = 1
print(minnum)
|
D, G = list(map(int, input().split()))
G //= 100
P = []
C = []
for i in range(1, D+1):
p, c = list(map(int, input().split()))
P.append(p)
C.append(c//100)
scores = []
nums = []
for i in range(0, 2**D):
score = 0
num = 0
remain = []
for j in range(D):
if (i>>j)&1:
score += P[j]*(j+1) + C[j]
num += P[j]
else:
remain.append(j)
if score >= G:
scores.append(score)
nums.append(num)
else:
remain = sorted(remain, reverse=True)
nokori = G - score
for r in remain:
if P[r] > -(-nokori // (r+1)):
num += -(-nokori // (r+1))
nums.append(num)
break
print((min(nums)))
| 36
| 33
| 804
| 766
|
D, G = list(map(int, input().split()))
G = G // 100
P = []
C = []
for i in range(1, D + 1):
p, c = list(map(int, input().split()))
P.append(p)
C.append(c // 100)
minnum = 1e9
for i in range(0, 2**D):
total = 0
num = 0
serach0 = [0] * D
for j in range(D):
if (i >> j) & 1:
total += P[j] * (j + 1) + C[j]
num += P[j]
serach0[j] = 1
if total >= G:
minnum = min(minnum, num)
continue
while 0 in serach0:
idx = serach0.index(0)
total_ = total
num_ = num
for _ in range(P[idx]):
total_ += idx + 1
num_ += 1
if total_ >= G:
minnum = min(minnum, num_)
break
serach0[idx] = 1
print(minnum)
|
D, G = list(map(int, input().split()))
G //= 100
P = []
C = []
for i in range(1, D + 1):
p, c = list(map(int, input().split()))
P.append(p)
C.append(c // 100)
scores = []
nums = []
for i in range(0, 2**D):
score = 0
num = 0
remain = []
for j in range(D):
if (i >> j) & 1:
score += P[j] * (j + 1) + C[j]
num += P[j]
else:
remain.append(j)
if score >= G:
scores.append(score)
nums.append(num)
else:
remain = sorted(remain, reverse=True)
nokori = G - score
for r in remain:
if P[r] > -(-nokori // (r + 1)):
num += -(-nokori // (r + 1))
nums.append(num)
break
print((min(nums)))
| false
| 8.333333
|
[
"-G = G // 100",
"+G //= 100",
"-minnum = 1e9",
"+scores = []",
"+nums = []",
"- total = 0",
"+ score = 0",
"- serach0 = [0] * D",
"+ remain = []",
"- total += P[j] * (j + 1) + C[j]",
"+ score += P[j] * (j + 1) + C[j]",
"- serach0[j] = 1",
"- if total >= G:",
"- minnum = min(minnum, num)",
"- continue",
"- while 0 in serach0:",
"- idx = serach0.index(0)",
"- total_ = total",
"- num_ = num",
"- for _ in range(P[idx]):",
"- total_ += idx + 1",
"- num_ += 1",
"- if total_ >= G:",
"- minnum = min(minnum, num_)",
"+ else:",
"+ remain.append(j)",
"+ if score >= G:",
"+ scores.append(score)",
"+ nums.append(num)",
"+ else:",
"+ remain = sorted(remain, reverse=True)",
"+ nokori = G - score",
"+ for r in remain:",
"+ if P[r] > -(-nokori // (r + 1)):",
"+ num += -(-nokori // (r + 1))",
"+ nums.append(num)",
"- serach0[idx] = 1",
"-print(minnum)",
"+print((min(nums)))"
] | false
| 0.035646
| 0.033332
| 1.069429
|
[
"s479686717",
"s035417406"
] |
u877470159
|
p03253
|
python
|
s860571208
|
s307205176
| 1,980
| 172
| 115,420
| 38,640
|
Accepted
|
Accepted
| 91.31
|
n,M=list(map(int,input().split()))
from math import factorial
i=2
c_list=[]
m=M
while i**2<=M:
count=0
while m%i==0:
m=m//i
count=count+1
if not count==0:
c_list.append(count)
i=i+1
if not m==1:
c_list.append(1)
if M==1:
print((1))
else:
INF=10**9+7
Sum=1
for i in c_list:
Sum=Sum*(factorial(n-1+i)//(factorial(n-1)*factorial(i)))
Sum=Sum%INF
print(Sum)
|
n,M=list(map(int,input().split()))
i=2
c_list=[]
m=M
while i**2<=M:
count=0
while m%i==0:
m=m//i
count=count+1
if not count==0:
c_list.append(count)
i=i+1
if not m==1:
c_list.append(1)
def comb(x,y):
a=1
for i in range(x-y+1,x+1):
a=a*i
b=1
for i in range(1,y+1):
b=b*i
return a//b
if M==1:
print((1))
else:
INF=10**9+7
Sum=1
for i in c_list:
Sum=Sum*comb(i+n-1,i)
Sum=Sum%INF
print(Sum)
| 24
| 31
| 449
| 526
|
n, M = list(map(int, input().split()))
from math import factorial
i = 2
c_list = []
m = M
while i**2 <= M:
count = 0
while m % i == 0:
m = m // i
count = count + 1
if not count == 0:
c_list.append(count)
i = i + 1
if not m == 1:
c_list.append(1)
if M == 1:
print((1))
else:
INF = 10**9 + 7
Sum = 1
for i in c_list:
Sum = Sum * (factorial(n - 1 + i) // (factorial(n - 1) * factorial(i)))
Sum = Sum % INF
print(Sum)
|
n, M = list(map(int, input().split()))
i = 2
c_list = []
m = M
while i**2 <= M:
count = 0
while m % i == 0:
m = m // i
count = count + 1
if not count == 0:
c_list.append(count)
i = i + 1
if not m == 1:
c_list.append(1)
def comb(x, y):
a = 1
for i in range(x - y + 1, x + 1):
a = a * i
b = 1
for i in range(1, y + 1):
b = b * i
return a // b
if M == 1:
print((1))
else:
INF = 10**9 + 7
Sum = 1
for i in c_list:
Sum = Sum * comb(i + n - 1, i)
Sum = Sum % INF
print(Sum)
| false
| 22.580645
|
[
"-from math import factorial",
"-",
"+",
"+",
"+def comb(x, y):",
"+ a = 1",
"+ for i in range(x - y + 1, x + 1):",
"+ a = a * i",
"+ b = 1",
"+ for i in range(1, y + 1):",
"+ b = b * i",
"+ return a // b",
"+",
"+",
"- Sum = Sum * (factorial(n - 1 + i) // (factorial(n - 1) * factorial(i)))",
"+ Sum = Sum * comb(i + n - 1, i)"
] | false
| 1.025172
| 0.03757
| 27.28689
|
[
"s860571208",
"s307205176"
] |
u998733244
|
p02791
|
python
|
s393762136
|
s135965729
| 271
| 167
| 76,624
| 24,744
|
Accepted
|
Accepted
| 38.38
|
N = int(eval(input()))
P = list(map(int, input().split()))
ans = 1
index = P[0]
for i in range(1, N):
if index > P[i]:
index = P[i]
ans += 1
print(ans)
|
#!/usr/bin/env python3
N = int(eval(input()))
P = list(map(int, input().split()))
M = [0] * N
M[0] = P[0]
m = P[0]
for i in range(1, N):
m = min(P[i], m)
M[i] = m
ans = 0
for i in range(N):
if P[i] <= M[i]:ans+=1
print(ans)
| 13
| 17
| 182
| 250
|
N = int(eval(input()))
P = list(map(int, input().split()))
ans = 1
index = P[0]
for i in range(1, N):
if index > P[i]:
index = P[i]
ans += 1
print(ans)
|
#!/usr/bin/env python3
N = int(eval(input()))
P = list(map(int, input().split()))
M = [0] * N
M[0] = P[0]
m = P[0]
for i in range(1, N):
m = min(P[i], m)
M[i] = m
ans = 0
for i in range(N):
if P[i] <= M[i]:
ans += 1
print(ans)
| false
| 23.529412
|
[
"+#!/usr/bin/env python3",
"-ans = 1",
"-index = P[0]",
"+M = [0] * N",
"+M[0] = P[0]",
"+m = P[0]",
"- if index > P[i]:",
"- index = P[i]",
"+ m = min(P[i], m)",
"+ M[i] = m",
"+ans = 0",
"+for i in range(N):",
"+ if P[i] <= M[i]:"
] | false
| 0.048795
| 0.062957
| 0.77504
|
[
"s393762136",
"s135965729"
] |
u367701763
|
p02702
|
python
|
s063697039
|
s239024928
| 87
| 78
| 84,280
| 73,772
|
Accepted
|
Accepted
| 10.34
|
# https://atcoder.jp/contests/abc164/tasks/abc164_d
import sys
input = sys.stdin.readline
S = input().rstrip()
res = 0
T = [0]
x = 0
p = 1
L = len(S)
MOD = 2019
for s in reversed(S):
""" 累積和 """
x = (int(s)*p + x)%MOD
p = p*10%MOD
T.append(x)
reminder = [0]*2019
for i in range(L+1):
reminder[T[i]%MOD] += 1
for c in reminder:
res += c*(c-1)//2
print(res)
|
# https://atcoder.jp/contests/abc164/tasks/abc164_d
import sys
input = sys.stdin.readline
S = input().rstrip()
res = 0
x = 0
p = 1
L = len(S)
MOD = 2019
reminder = [0]*2019
reminder[0] = 1
for s in reversed(S):
""" 累積和 """
x = (int(s)*p + x)%MOD
p = p*10%MOD
reminder[x] += 1
for c in reminder:
res += c*(c-1)//2
print(res)
| 29
| 26
| 415
| 375
|
# https://atcoder.jp/contests/abc164/tasks/abc164_d
import sys
input = sys.stdin.readline
S = input().rstrip()
res = 0
T = [0]
x = 0
p = 1
L = len(S)
MOD = 2019
for s in reversed(S):
"""累積和"""
x = (int(s) * p + x) % MOD
p = p * 10 % MOD
T.append(x)
reminder = [0] * 2019
for i in range(L + 1):
reminder[T[i] % MOD] += 1
for c in reminder:
res += c * (c - 1) // 2
print(res)
|
# https://atcoder.jp/contests/abc164/tasks/abc164_d
import sys
input = sys.stdin.readline
S = input().rstrip()
res = 0
x = 0
p = 1
L = len(S)
MOD = 2019
reminder = [0] * 2019
reminder[0] = 1
for s in reversed(S):
"""累積和"""
x = (int(s) * p + x) % MOD
p = p * 10 % MOD
reminder[x] += 1
for c in reminder:
res += c * (c - 1) // 2
print(res)
| false
| 10.344828
|
[
"-T = [0]",
"+reminder = [0] * 2019",
"+reminder[0] = 1",
"- T.append(x)",
"-reminder = [0] * 2019",
"-for i in range(L + 1):",
"- reminder[T[i] % MOD] += 1",
"+ reminder[x] += 1"
] | false
| 0.094042
| 0.047099
| 1.996706
|
[
"s063697039",
"s239024928"
] |
u276204978
|
p03087
|
python
|
s600492392
|
s940594852
| 973
| 837
| 5,720
| 7,748
|
Accepted
|
Accepted
| 13.98
|
import bisect
def solve():
N, Q = list(map(int, input().split()))
S = eval(input())
index = []
for i in range(N-1):
if S[i:i+2] == 'AC':
index.append(i+1)
for _ in range(Q):
l, r = list(map(int, input().split()))
print((bisect.bisect_left(index, r) - bisect.bisect_left(index, l)))
solve()
|
def solve():
N, Q = list(map(int, input().split()))
S = eval(input())
t = [0] * (N+1)
for i in range(N):
t[i+1] = t[i] + (1 if S[i:i+2] == 'AC' else 0)
for _ in range(Q):
l, r = list(map(int, input().split()))
print((t[r-1]-t[l-1]))
solve()
| 15
| 13
| 354
| 297
|
import bisect
def solve():
N, Q = list(map(int, input().split()))
S = eval(input())
index = []
for i in range(N - 1):
if S[i : i + 2] == "AC":
index.append(i + 1)
for _ in range(Q):
l, r = list(map(int, input().split()))
print((bisect.bisect_left(index, r) - bisect.bisect_left(index, l)))
solve()
|
def solve():
N, Q = list(map(int, input().split()))
S = eval(input())
t = [0] * (N + 1)
for i in range(N):
t[i + 1] = t[i] + (1 if S[i : i + 2] == "AC" else 0)
for _ in range(Q):
l, r = list(map(int, input().split()))
print((t[r - 1] - t[l - 1]))
solve()
| false
| 13.333333
|
[
"-import bisect",
"-",
"-",
"- index = []",
"- for i in range(N - 1):",
"- if S[i : i + 2] == \"AC\":",
"- index.append(i + 1)",
"+ t = [0] * (N + 1)",
"+ for i in range(N):",
"+ t[i + 1] = t[i] + (1 if S[i : i + 2] == \"AC\" else 0)",
"- print((bisect.bisect_left(index, r) - bisect.bisect_left(index, l)))",
"+ print((t[r - 1] - t[l - 1]))"
] | false
| 0.061155
| 0.036938
| 1.655641
|
[
"s600492392",
"s940594852"
] |
u614314290
|
p03221
|
python
|
s021885965
|
s785065164
| 705
| 547
| 70,812
| 58,252
|
Accepted
|
Accepted
| 22.41
|
N, M = list(map(int, input().split()))
PY = [list(map(int, input().split())) for _ in range(M)]
groups = [[] for _ in range(N + 1)]
for p, y in PY:
groups[p] += [y]
for i, g in enumerate(groups):
g.sort()
cities = {}
for j, t in enumerate(g):
cities[t] = j + 1
groups[i] = cities
for p, y in PY:
print(("{:06d}{:06d}".format(p, groups[p][y])))
|
import sys
from math import factorial, ceil, floor
from bisect import bisect_right as bsr
from operator import itemgetter as ig
from collections import defaultdict as dd
from collections import deque
# お約束
args = None
INF = float("inf")
MOD = int(1e9 + 7)
def input(*ps):
if len(ps) == 0:
return next(args)
elif type(ps[0]) is list:
return [eval(input(*ps[0][0])) for _ in range(ps[0][1])]
elif len(ps) == 1:
return ps[0](next(args))
else:
return [p(next(args)) for p in ps]
# エントリーポイント
def main():
N, M = eval(input(int, int))
ps = dd(list)
for i in range(M):
p, y = eval(input(int, int))
ps[p].append((y, i))
ans = [None] * M
for k, v in list(ps.items()):
v.sort()
for i, c in enumerate(v, start=1):
ans[c[1]] = (k, i)
for v in ans:
print(("{:06d}{:06d}".format(v[0], v[1])))
if __name__ == '__main__':
args = iter(sys.stdin.read().split())
main()
| 16
| 40
| 362
| 999
|
N, M = list(map(int, input().split()))
PY = [list(map(int, input().split())) for _ in range(M)]
groups = [[] for _ in range(N + 1)]
for p, y in PY:
groups[p] += [y]
for i, g in enumerate(groups):
g.sort()
cities = {}
for j, t in enumerate(g):
cities[t] = j + 1
groups[i] = cities
for p, y in PY:
print(("{:06d}{:06d}".format(p, groups[p][y])))
|
import sys
from math import factorial, ceil, floor
from bisect import bisect_right as bsr
from operator import itemgetter as ig
from collections import defaultdict as dd
from collections import deque
# お約束
args = None
INF = float("inf")
MOD = int(1e9 + 7)
def input(*ps):
if len(ps) == 0:
return next(args)
elif type(ps[0]) is list:
return [eval(input(*ps[0][0])) for _ in range(ps[0][1])]
elif len(ps) == 1:
return ps[0](next(args))
else:
return [p(next(args)) for p in ps]
# エントリーポイント
def main():
N, M = eval(input(int, int))
ps = dd(list)
for i in range(M):
p, y = eval(input(int, int))
ps[p].append((y, i))
ans = [None] * M
for k, v in list(ps.items()):
v.sort()
for i, c in enumerate(v, start=1):
ans[c[1]] = (k, i)
for v in ans:
print(("{:06d}{:06d}".format(v[0], v[1])))
if __name__ == "__main__":
args = iter(sys.stdin.read().split())
main()
| false
| 60
|
[
"-N, M = list(map(int, input().split()))",
"-PY = [list(map(int, input().split())) for _ in range(M)]",
"-groups = [[] for _ in range(N + 1)]",
"-for p, y in PY:",
"- groups[p] += [y]",
"-for i, g in enumerate(groups):",
"- g.sort()",
"- cities = {}",
"- for j, t in enumerate(g):",
"- cities[t] = j + 1",
"- groups[i] = cities",
"-for p, y in PY:",
"- print((\"{:06d}{:06d}\".format(p, groups[p][y])))",
"+import sys",
"+from math import factorial, ceil, floor",
"+from bisect import bisect_right as bsr",
"+from operator import itemgetter as ig",
"+from collections import defaultdict as dd",
"+from collections import deque",
"+",
"+# お約束",
"+args = None",
"+INF = float(\"inf\")",
"+MOD = int(1e9 + 7)",
"+",
"+",
"+def input(*ps):",
"+ if len(ps) == 0:",
"+ return next(args)",
"+ elif type(ps[0]) is list:",
"+ return [eval(input(*ps[0][0])) for _ in range(ps[0][1])]",
"+ elif len(ps) == 1:",
"+ return ps[0](next(args))",
"+ else:",
"+ return [p(next(args)) for p in ps]",
"+",
"+",
"+# エントリーポイント",
"+def main():",
"+ N, M = eval(input(int, int))",
"+ ps = dd(list)",
"+ for i in range(M):",
"+ p, y = eval(input(int, int))",
"+ ps[p].append((y, i))",
"+ ans = [None] * M",
"+ for k, v in list(ps.items()):",
"+ v.sort()",
"+ for i, c in enumerate(v, start=1):",
"+ ans[c[1]] = (k, i)",
"+ for v in ans:",
"+ print((\"{:06d}{:06d}\".format(v[0], v[1])))",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ args = iter(sys.stdin.read().split())",
"+ main()"
] | false
| 0.036296
| 0.038691
| 0.938089
|
[
"s021885965",
"s785065164"
] |
u414699019
|
p02862
|
python
|
s127917919
|
s285871468
| 887
| 130
| 82,296
| 3,064
|
Accepted
|
Accepted
| 85.34
|
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
x,y=list(map(int,input().split()))
if (2*y-x)%3==0:
a=(2*y-x)//3
b=(2*x-y)//3
mod = 10**9+7 #出力の制限
N = a+b
r=min(a,b)
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range( 2, N + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
print((cmb(N,r,mod)))
else:
print((0))
|
def cmb(n,r,mod):
r=min(r,n-r)
if r==0:
return 1
elif r<0:
return 0
else:
X=1
Y=1
for i in range(r):
X*=n-i
X%=mod
Y*=i+1
Y%=mod
Y=pow(Y,mod-2,mod)
X*=Y
return X%mod
if __name__ == "__main__":
X,Y=list(map(int,input().split()))
if (2*Y-X)%3!=0 or (2*X-Y)%3!=0:
print((0))
else:
xd=(2*X-Y)//3
yd=(2*Y-X)//3
print((cmb(xd+yd,yd,10**9+7)))
| 26
| 26
| 597
| 524
|
def cmb(n, r, mod):
if r < 0 or r > n:
return 0
r = min(r, n - r)
return g1[n] * g2[r] * g2[n - r] % mod
x, y = list(map(int, input().split()))
if (2 * y - x) % 3 == 0:
a = (2 * y - x) // 3
b = (2 * x - y) // 3
mod = 10**9 + 7 # 出力の制限
N = a + b
r = min(a, b)
g1 = [1, 1] # 元テーブル
g2 = [1, 1] # 逆元テーブル
inverse = [0, 1] # 逆元テーブル計算用テーブル
for i in range(2, N + 1):
g1.append((g1[-1] * i) % mod)
inverse.append((-inverse[mod % i] * (mod // i)) % mod)
g2.append((g2[-1] * inverse[-1]) % mod)
print((cmb(N, r, mod)))
else:
print((0))
|
def cmb(n, r, mod):
r = min(r, n - r)
if r == 0:
return 1
elif r < 0:
return 0
else:
X = 1
Y = 1
for i in range(r):
X *= n - i
X %= mod
Y *= i + 1
Y %= mod
Y = pow(Y, mod - 2, mod)
X *= Y
return X % mod
if __name__ == "__main__":
X, Y = list(map(int, input().split()))
if (2 * Y - X) % 3 != 0 or (2 * X - Y) % 3 != 0:
print((0))
else:
xd = (2 * X - Y) // 3
yd = (2 * Y - X) // 3
print((cmb(xd + yd, yd, 10**9 + 7)))
| false
| 0
|
[
"- if r < 0 or r > n:",
"+ r = min(r, n - r)",
"+ if r == 0:",
"+ return 1",
"+ elif r < 0:",
"- r = min(r, n - r)",
"- return g1[n] * g2[r] * g2[n - r] % mod",
"+ else:",
"+ X = 1",
"+ Y = 1",
"+ for i in range(r):",
"+ X *= n - i",
"+ X %= mod",
"+ Y *= i + 1",
"+ Y %= mod",
"+ Y = pow(Y, mod - 2, mod)",
"+ X *= Y",
"+ return X % mod",
"-x, y = list(map(int, input().split()))",
"-if (2 * y - x) % 3 == 0:",
"- a = (2 * y - x) // 3",
"- b = (2 * x - y) // 3",
"- mod = 10**9 + 7 # 出力の制限",
"- N = a + b",
"- r = min(a, b)",
"- g1 = [1, 1] # 元テーブル",
"- g2 = [1, 1] # 逆元テーブル",
"- inverse = [0, 1] # 逆元テーブル計算用テーブル",
"- for i in range(2, N + 1):",
"- g1.append((g1[-1] * i) % mod)",
"- inverse.append((-inverse[mod % i] * (mod // i)) % mod)",
"- g2.append((g2[-1] * inverse[-1]) % mod)",
"- print((cmb(N, r, mod)))",
"-else:",
"- print((0))",
"+if __name__ == \"__main__\":",
"+ X, Y = list(map(int, input().split()))",
"+ if (2 * Y - X) % 3 != 0 or (2 * X - Y) % 3 != 0:",
"+ print((0))",
"+ else:",
"+ xd = (2 * X - Y) // 3",
"+ yd = (2 * Y - X) // 3",
"+ print((cmb(xd + yd, yd, 10**9 + 7)))"
] | false
| 0.231962
| 0.052765
| 4.396164
|
[
"s127917919",
"s285871468"
] |
u780475861
|
p02822
|
python
|
s826579308
|
s522160732
| 1,287
| 934
| 174,384
| 59,304
|
Accepted
|
Accepted
| 27.43
|
import sys
sys.setrecursionlimit(1000000)
readline = sys.stdin.readline
N = int(readline())
adj = [[] for i in range(N)]
for i in range(N - 1):
A, B = list(map(int, readline().split()))
A -= 1
B -= 1
adj[A].append(B)
adj[B].append(A)
mod = 10 ** 9 + 7
pow2 = [1] * (N + 1)
for i, j in zip(list(range(N)), list(range(1, N + 1))):
pow2[j] = pow2[i] * 2 % mod
ans = 0
def dfs(node, parent):
global ans
cnt = 1
for child in adj[node]:
if child != parent:
cnt += dfs(child, node)
ans += (pow2[cnt] - 1) * (pow2[N-cnt] - 1)
ans %= mod
return cnt
dfs(0, None)
ans = (ans - N * pow2[N-1] + pow2[N] - 1) % mod
ans = ans * pow(pow2[N], mod - 2, mod) % mod
print(ans)
|
import sys
readline = sys.stdin.readline
N = int(readline())
graph = [[] for _ in range(N + 1)]
for i in range(N - 1):
a, b = list(map(int, readline().split()))
graph[a].append(b)
graph[b].append(a)
parent = [0] * (N + 1)
order = []
stack = [1]
while stack:
x = stack.pop()
order.append(x) # 行きがけ順探索リスト
for y in graph[x]:
if y == parent[x]:
continue
parent[y] = x # 親ノードを記録
stack.append(y)
MOD = 10**9 + 7
half = pow(2, MOD - 2, MOD)
power_inv = [1] * (N + 1)
size = [1] * (N + 1)
for i, v in enumerate(order[::-1], 1):
p = parent[v]
x = size[v] # vの子孫ノード数（自分も含む）をとる
size[p] += x # 親にノード数を加算
power_inv[i] = power_inv[i - 1] * half % MOD # [1, 1/2, 1/4, ...]
ans = sum((1 - power_inv[i] - power_inv[N - i] + power_inv[N]) % MOD for i in size[2:]) # 解法1の確率式(ノード1を除く)
ans += (1 - power_inv[N]) - N * power_inv[1] # + - N/2
ans %= MOD
print(ans)
| 41
| 37
| 771
| 961
|
import sys
sys.setrecursionlimit(1000000)
readline = sys.stdin.readline
N = int(readline())
adj = [[] for i in range(N)]
for i in range(N - 1):
A, B = list(map(int, readline().split()))
A -= 1
B -= 1
adj[A].append(B)
adj[B].append(A)
mod = 10**9 + 7
pow2 = [1] * (N + 1)
for i, j in zip(list(range(N)), list(range(1, N + 1))):
pow2[j] = pow2[i] * 2 % mod
ans = 0
def dfs(node, parent):
global ans
cnt = 1
for child in adj[node]:
if child != parent:
cnt += dfs(child, node)
ans += (pow2[cnt] - 1) * (pow2[N - cnt] - 1)
ans %= mod
return cnt
dfs(0, None)
ans = (ans - N * pow2[N - 1] + pow2[N] - 1) % mod
ans = ans * pow(pow2[N], mod - 2, mod) % mod
print(ans)
|
import sys
readline = sys.stdin.readline
N = int(readline())
graph = [[] for _ in range(N + 1)]
for i in range(N - 1):
a, b = list(map(int, readline().split()))
graph[a].append(b)
graph[b].append(a)
parent = [0] * (N + 1)
order = []
stack = [1]
while stack:
x = stack.pop()
order.append(x) # 行きがけ順探索リスト
for y in graph[x]:
if y == parent[x]:
continue
parent[y] = x # 親ノードを記録
stack.append(y)
MOD = 10**9 + 7
half = pow(2, MOD - 2, MOD)
power_inv = [1] * (N + 1)
size = [1] * (N + 1)
for i, v in enumerate(order[::-1], 1):
p = parent[v]
x = size[v] # vの子孫ノード数（自分も含む）をとる
size[p] += x # 親にノード数を加算
power_inv[i] = power_inv[i - 1] * half % MOD # [1, 1/2, 1/4, ...]
ans = sum(
(1 - power_inv[i] - power_inv[N - i] + power_inv[N]) % MOD for i in size[2:]
) # 解法1の確率式(ノード1を除く)
ans += (1 - power_inv[N]) - N * power_inv[1] # + - N/2
ans %= MOD
print(ans)
| false
| 9.756098
|
[
"-sys.setrecursionlimit(1000000)",
"-adj = [[] for i in range(N)]",
"+graph = [[] for _ in range(N + 1)]",
"- A, B = list(map(int, readline().split()))",
"- A -= 1",
"- B -= 1",
"- adj[A].append(B)",
"- adj[B].append(A)",
"-mod = 10**9 + 7",
"-pow2 = [1] * (N + 1)",
"-for i, j in zip(list(range(N)), list(range(1, N + 1))):",
"- pow2[j] = pow2[i] * 2 % mod",
"-ans = 0",
"-",
"-",
"-def dfs(node, parent):",
"- global ans",
"- cnt = 1",
"- for child in adj[node]:",
"- if child != parent:",
"- cnt += dfs(child, node)",
"- ans += (pow2[cnt] - 1) * (pow2[N - cnt] - 1)",
"- ans %= mod",
"- return cnt",
"-",
"-",
"-dfs(0, None)",
"-ans = (ans - N * pow2[N - 1] + pow2[N] - 1) % mod",
"-ans = ans * pow(pow2[N], mod - 2, mod) % mod",
"+ a, b = list(map(int, readline().split()))",
"+ graph[a].append(b)",
"+ graph[b].append(a)",
"+parent = [0] * (N + 1)",
"+order = []",
"+stack = [1]",
"+while stack:",
"+ x = stack.pop()",
"+ order.append(x) # 行きがけ順探索リスト",
"+ for y in graph[x]:",
"+ if y == parent[x]:",
"+ continue",
"+ parent[y] = x # 親ノードを記録",
"+ stack.append(y)",
"+MOD = 10**9 + 7",
"+half = pow(2, MOD - 2, MOD)",
"+power_inv = [1] * (N + 1)",
"+size = [1] * (N + 1)",
"+for i, v in enumerate(order[::-1], 1):",
"+ p = parent[v]",
"+ x = size[v] # vの子孫ノード数（自分も含む）をとる",
"+ size[p] += x # 親にノード数を加算",
"+ power_inv[i] = power_inv[i - 1] * half % MOD # [1, 1/2, 1/4, ...]",
"+ans = sum(",
"+ (1 - power_inv[i] - power_inv[N - i] + power_inv[N]) % MOD for i in size[2:]",
"+) # 解法1の確率式(ノード1を除く)",
"+ans += (1 - power_inv[N]) - N * power_inv[1] # + - N/2",
"+ans %= MOD"
] | false
| 0.035709
| 0.037029
| 0.964372
|
[
"s826579308",
"s522160732"
] |
u683134447
|
p03074
|
python
|
s720229609
|
s895547667
| 1,848
| 196
| 49,648
| 49,648
|
Accepted
|
Accepted
| 89.39
|
n,k = list(map(int,input().split()))
sl = list(eval(input()))
l = []
l.append(0)
ans = 0
before = ""
count = 0
if sl[0] == "0":
l.append(0)
for idx,s in enumerate(sl):
if s != before:
before = s
if idx > 0:
l.append(idx)
if len(l) == 2*k + 2:
ans = max(l[-1] - l[0], ans)
l.pop(0)
l.pop(0)
l.append(n)
ans = max(l[-1] - l[0], ans)
print(ans)
|
from collections import deque
n,k = list(map(int,input().split()))
sl = list(eval(input()))
d = deque([])
ans = 0
before = "1"
tmp = 0
p = 0
for s in sl:
if before == s:
p += 1
else:
d.append(p)
tmp += p
p = 1
before = s
if len(d) == 2 * k + 1:
ans = max(tmp, ans)
tmp -= d.popleft()
tmp -= d.popleft()
else:
d.append(p)
tmp += p
ans = max(tmp, ans)
print(ans)
| 22
| 27
| 423
| 464
|
n, k = list(map(int, input().split()))
sl = list(eval(input()))
l = []
l.append(0)
ans = 0
before = ""
count = 0
if sl[0] == "0":
l.append(0)
for idx, s in enumerate(sl):
if s != before:
before = s
if idx > 0:
l.append(idx)
if len(l) == 2 * k + 2:
ans = max(l[-1] - l[0], ans)
l.pop(0)
l.pop(0)
l.append(n)
ans = max(l[-1] - l[0], ans)
print(ans)
|
from collections import deque
n, k = list(map(int, input().split()))
sl = list(eval(input()))
d = deque([])
ans = 0
before = "1"
tmp = 0
p = 0
for s in sl:
if before == s:
p += 1
else:
d.append(p)
tmp += p
p = 1
before = s
if len(d) == 2 * k + 1:
ans = max(tmp, ans)
tmp -= d.popleft()
tmp -= d.popleft()
else:
d.append(p)
tmp += p
ans = max(tmp, ans)
print(ans)
| false
| 18.518519
|
[
"+from collections import deque",
"+",
"-l = []",
"-l.append(0)",
"+d = deque([])",
"-before = \"\"",
"-count = 0",
"-if sl[0] == \"0\":",
"- l.append(0)",
"-for idx, s in enumerate(sl):",
"- if s != before:",
"+before = \"1\"",
"+tmp = 0",
"+p = 0",
"+for s in sl:",
"+ if before == s:",
"+ p += 1",
"+ else:",
"+ d.append(p)",
"+ tmp += p",
"+ p = 1",
"- if idx > 0:",
"- l.append(idx)",
"- if len(l) == 2 * k + 2:",
"- ans = max(l[-1] - l[0], ans)",
"- l.pop(0)",
"- l.pop(0)",
"-l.append(n)",
"-ans = max(l[-1] - l[0], ans)",
"+ if len(d) == 2 * k + 1:",
"+ ans = max(tmp, ans)",
"+ tmp -= d.popleft()",
"+ tmp -= d.popleft()",
"+else:",
"+ d.append(p)",
"+ tmp += p",
"+ ans = max(tmp, ans)"
] | false
| 0.048419
| 0.035562
| 1.361553
|
[
"s720229609",
"s895547667"
] |
u961683878
|
p02806
|
python
|
s634873271
|
s178719517
| 477
| 153
| 21,884
| 12,468
|
Accepted
|
Accepted
| 67.92
|
import sys
import numpy as np
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(500000)
n = int(readline())
S = []
T = []
for i in range(n):
s, t = readline().decode('utf-8').split()
t = int(t)
S.append(s)
T.append(t)
X = readline().decode('utf-8').split()[0]
idx = S.index(X)
res = sum(T[idx+1:])
print(res)
|
import sys
import numpy as np
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(500000)
N = int(readline())
ST = [readline().split() for _ in range(N)]
X = read().rstrip()
S, T = list(zip(*ST))
idx = S.index(X)
res = sum(map(int, T[idx+1:]))
print(res)
| 21
| 17
| 425
| 344
|
import sys
import numpy as np
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(500000)
n = int(readline())
S = []
T = []
for i in range(n):
s, t = readline().decode("utf-8").split()
t = int(t)
S.append(s)
T.append(t)
X = readline().decode("utf-8").split()[0]
idx = S.index(X)
res = sum(T[idx + 1 :])
print(res)
|
import sys
import numpy as np
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(500000)
N = int(readline())
ST = [readline().split() for _ in range(N)]
X = read().rstrip()
S, T = list(zip(*ST))
idx = S.index(X)
res = sum(map(int, T[idx + 1 :]))
print(res)
| false
| 19.047619
|
[
"-n = int(readline())",
"-S = []",
"-T = []",
"-for i in range(n):",
"- s, t = readline().decode(\"utf-8\").split()",
"- t = int(t)",
"- S.append(s)",
"- T.append(t)",
"-X = readline().decode(\"utf-8\").split()[0]",
"+N = int(readline())",
"+ST = [readline().split() for _ in range(N)]",
"+X = read().rstrip()",
"+S, T = list(zip(*ST))",
"-res = sum(T[idx + 1 :])",
"+res = sum(map(int, T[idx + 1 :]))"
] | false
| 0.046604
| 0.04669
| 0.998164
|
[
"s634873271",
"s178719517"
] |
u072053884
|
p01545
|
python
|
s549310201
|
s381311295
| 2,360
| 480
| 18,100
| 16,188
|
Accepted
|
Accepted
| 79.66
|
class RangeMaximumQuery:
def __init__(self, n):
self.size = n
self.dat = [0] * (2 * n - 1)
def update(self, i, x):
i += self.size - 1
self.dat[i] = x
while i > 0:
i = (i - 1) // 2
d1 = self.dat[i * 2 + 1]
d2 = self.dat[i * 2 + 2]
if d1 > d2:
self.dat[i] = d1
else:
self.dat[i] = d2
def getmax(self, a, b, k, l, r):
if r <= a or b <= l:
return 0
elif a <= l and r <= b:
return self.dat[k]
else:
vl = self.getmax(a, b, k * 2 + 1, l, (l + r) // 2)
vr = self.getmax(a, b, k * 2 + 2, (l + r) // 2, r)
if vl > vr:
return vl
else:
return vr
def solve():
from math import ceil, log
n = int(eval(input()))
A = list(map(int, input().split()))
s = 2 ** ceil(log(n, 2))
W = RangeMaximumQuery(s)
for a_i in A:
cost = W.getmax(0, a_i - 1, 0, 0, s) + a_i
W.update(a_i - 1, cost)
ans = n * (n + 1) // 2 - W.getmax(0, n, 0, 0, s)
print(ans)
solve()
|
def solve():
n = int(eval(input()))
dp = [0] * (n + 1)
def update(i, x):
while i <= n:
if dp[i] < x:
dp[i] = x
i += i & -i
def get_sum(i):
s = 0
while i > 0:
t = dp[i]
if s < t:
s = t
i -= i & -i
return s
A = list(map(int, input().split()))
for a_i in A:
update(a_i, get_sum(a_i - 1) + a_i)
ans = n * (n + 1) // 2 - get_sum(n)
print(ans)
solve()
| 44
| 28
| 1,200
| 551
|
class RangeMaximumQuery:
def __init__(self, n):
self.size = n
self.dat = [0] * (2 * n - 1)
def update(self, i, x):
i += self.size - 1
self.dat[i] = x
while i > 0:
i = (i - 1) // 2
d1 = self.dat[i * 2 + 1]
d2 = self.dat[i * 2 + 2]
if d1 > d2:
self.dat[i] = d1
else:
self.dat[i] = d2
def getmax(self, a, b, k, l, r):
if r <= a or b <= l:
return 0
elif a <= l and r <= b:
return self.dat[k]
else:
vl = self.getmax(a, b, k * 2 + 1, l, (l + r) // 2)
vr = self.getmax(a, b, k * 2 + 2, (l + r) // 2, r)
if vl > vr:
return vl
else:
return vr
def solve():
from math import ceil, log
n = int(eval(input()))
A = list(map(int, input().split()))
s = 2 ** ceil(log(n, 2))
W = RangeMaximumQuery(s)
for a_i in A:
cost = W.getmax(0, a_i - 1, 0, 0, s) + a_i
W.update(a_i - 1, cost)
ans = n * (n + 1) // 2 - W.getmax(0, n, 0, 0, s)
print(ans)
solve()
|
def solve():
n = int(eval(input()))
dp = [0] * (n + 1)
def update(i, x):
while i <= n:
if dp[i] < x:
dp[i] = x
i += i & -i
def get_sum(i):
s = 0
while i > 0:
t = dp[i]
if s < t:
s = t
i -= i & -i
return s
A = list(map(int, input().split()))
for a_i in A:
update(a_i, get_sum(a_i - 1) + a_i)
ans = n * (n + 1) // 2 - get_sum(n)
print(ans)
solve()
| false
| 36.363636
|
[
"-class RangeMaximumQuery:",
"- def __init__(self, n):",
"- self.size = n",
"- self.dat = [0] * (2 * n - 1)",
"+def solve():",
"+ n = int(eval(input()))",
"+ dp = [0] * (n + 1)",
"- def update(self, i, x):",
"- i += self.size - 1",
"- self.dat[i] = x",
"+ def update(i, x):",
"+ while i <= n:",
"+ if dp[i] < x:",
"+ dp[i] = x",
"+ i += i & -i",
"+",
"+ def get_sum(i):",
"+ s = 0",
"- i = (i - 1) // 2",
"- d1 = self.dat[i * 2 + 1]",
"- d2 = self.dat[i * 2 + 2]",
"- if d1 > d2:",
"- self.dat[i] = d1",
"- else:",
"- self.dat[i] = d2",
"+ t = dp[i]",
"+ if s < t:",
"+ s = t",
"+ i -= i & -i",
"+ return s",
"- def getmax(self, a, b, k, l, r):",
"- if r <= a or b <= l:",
"- return 0",
"- elif a <= l and r <= b:",
"- return self.dat[k]",
"- else:",
"- vl = self.getmax(a, b, k * 2 + 1, l, (l + r) // 2)",
"- vr = self.getmax(a, b, k * 2 + 2, (l + r) // 2, r)",
"- if vl > vr:",
"- return vl",
"- else:",
"- return vr",
"-",
"-",
"-def solve():",
"- from math import ceil, log",
"-",
"- n = int(eval(input()))",
"- s = 2 ** ceil(log(n, 2))",
"- W = RangeMaximumQuery(s)",
"- cost = W.getmax(0, a_i - 1, 0, 0, s) + a_i",
"- W.update(a_i - 1, cost)",
"- ans = n * (n + 1) // 2 - W.getmax(0, n, 0, 0, s)",
"+ update(a_i, get_sum(a_i - 1) + a_i)",
"+ ans = n * (n + 1) // 2 - get_sum(n)"
] | false
| 0.036739
| 0.04071
| 0.902438
|
[
"s549310201",
"s381311295"
] |
u690536347
|
p02574
|
python
|
s906548419
|
s645825568
| 1,254
| 409
| 229,636
| 230,976
|
Accepted
|
Accepted
| 67.38
|
from math import gcd
from functools import reduce
from collections import Counter
class Osa_k:
def __init__(self, maximum):
self.table = [-1] * (maximum+1)
for i in range(2, maximum+1):
if self.table[i] != -1:
continue
for j in range(2, int(i**0.5)+1):
if i%j == 0:
self.table[i] = j
for k in range(2*i, maximum+1, i):
if self.table[k] != -1:
self.table[k] = j
break
def factorize(self, n):
res = Counter()
b = n
while 1:
if self.table[b] == -1:
break
res[self.table[b]] += 1
b //= self.table[b]
res[b] += 1
return res
N = int(eval(input()))
*A, = list(map(int, input().split()))
def f():
cnt = Counter()
ins = Osa_k(max(A))
for i in A:
res = ins.factorize(i) if i!=1 else {}
for j in list(res.keys()):
cnt[j] += 1
if cnt[j] >= 2:
return False
return True
cond1 = f()
cond2 = (reduce(gcd, A)==1)
if cond1:
print("pairwise coprime")
elif cond2:
print("setwise coprime")
else:
print("not coprime")
|
from math import gcd
from functools import reduce
from collections import Counter
class Osa_k:
def __init__(self, maximum):
self.table = [-1] * (maximum+1)
for i in range(2, maximum+1):
if self.table[i] != -1:
continue
self.table[i] = i
for k in range(i*i, maximum+1, i):
if self.table[k] == -1:
self.table[k] = i
def factorize(self, n):
res = Counter()
b = n
while 1:
if self.table[b] == -1:
break
res[self.table[b]] += 1
b //= self.table[b]
if b != 1:
res[b] += 1
return res
N = int(eval(input()))
*A, = list(map(int, input().split()))
def f():
cnt = Counter()
ins = Osa_k(max(A))
for i in A:
res = ins.factorize(i)
for j in list(res.keys()):
cnt[j] += 1
if cnt[j] >= 2:
return False
return True
cond1 = f()
cond2 = (reduce(gcd, A)==1)
if cond1:
print("pairwise coprime")
elif cond2:
print("setwise coprime")
else:
print("not coprime")
| 53
| 51
| 1,305
| 1,177
|
from math import gcd
from functools import reduce
from collections import Counter
class Osa_k:
def __init__(self, maximum):
self.table = [-1] * (maximum + 1)
for i in range(2, maximum + 1):
if self.table[i] != -1:
continue
for j in range(2, int(i**0.5) + 1):
if i % j == 0:
self.table[i] = j
for k in range(2 * i, maximum + 1, i):
if self.table[k] != -1:
self.table[k] = j
break
def factorize(self, n):
res = Counter()
b = n
while 1:
if self.table[b] == -1:
break
res[self.table[b]] += 1
b //= self.table[b]
res[b] += 1
return res
N = int(eval(input()))
(*A,) = list(map(int, input().split()))
def f():
cnt = Counter()
ins = Osa_k(max(A))
for i in A:
res = ins.factorize(i) if i != 1 else {}
for j in list(res.keys()):
cnt[j] += 1
if cnt[j] >= 2:
return False
return True
cond1 = f()
cond2 = reduce(gcd, A) == 1
if cond1:
print("pairwise coprime")
elif cond2:
print("setwise coprime")
else:
print("not coprime")
|
from math import gcd
from functools import reduce
from collections import Counter
class Osa_k:
def __init__(self, maximum):
self.table = [-1] * (maximum + 1)
for i in range(2, maximum + 1):
if self.table[i] != -1:
continue
self.table[i] = i
for k in range(i * i, maximum + 1, i):
if self.table[k] == -1:
self.table[k] = i
def factorize(self, n):
res = Counter()
b = n
while 1:
if self.table[b] == -1:
break
res[self.table[b]] += 1
b //= self.table[b]
if b != 1:
res[b] += 1
return res
N = int(eval(input()))
(*A,) = list(map(int, input().split()))
def f():
cnt = Counter()
ins = Osa_k(max(A))
for i in A:
res = ins.factorize(i)
for j in list(res.keys()):
cnt[j] += 1
if cnt[j] >= 2:
return False
return True
cond1 = f()
cond2 = reduce(gcd, A) == 1
if cond1:
print("pairwise coprime")
elif cond2:
print("setwise coprime")
else:
print("not coprime")
| false
| 3.773585
|
[
"- for j in range(2, int(i**0.5) + 1):",
"- if i % j == 0:",
"- self.table[i] = j",
"- for k in range(2 * i, maximum + 1, i):",
"- if self.table[k] != -1:",
"- self.table[k] = j",
"- break",
"+ self.table[i] = i",
"+ for k in range(i * i, maximum + 1, i):",
"+ if self.table[k] == -1:",
"+ self.table[k] = i",
"- res[b] += 1",
"+ if b != 1:",
"+ res[b] += 1",
"- res = ins.factorize(i) if i != 1 else {}",
"+ res = ins.factorize(i)"
] | false
| 0.036006
| 0.04314
| 0.83462
|
[
"s906548419",
"s645825568"
] |
u057109575
|
p03103
|
python
|
s996284831
|
s651640601
| 482
| 410
| 27,756
| 90,340
|
Accepted
|
Accepted
| 14.94
|
N, M = list(map(int, input().split()))
X = [list(map(int, input().split())) for _ in range(N)]
X.sort()
ans = 0
res = M
for v in X:
ans += v[0] * min(v[1], res)
res -= v[1]
if res <= 0:
break
print(ans)
|
N, M = list(map(int, input().split()))
X = [list(map(int, input().split())) for _ in range(N)]
X.sort()
res = M
ans = 0
for a, b in X:
if res <= 0:
break
tmp = min(b, res)
res -= tmp
ans += tmp * a
print(ans)
| 13
| 16
| 239
| 246
|
N, M = list(map(int, input().split()))
X = [list(map(int, input().split())) for _ in range(N)]
X.sort()
ans = 0
res = M
for v in X:
ans += v[0] * min(v[1], res)
res -= v[1]
if res <= 0:
break
print(ans)
|
N, M = list(map(int, input().split()))
X = [list(map(int, input().split())) for _ in range(N)]
X.sort()
res = M
ans = 0
for a, b in X:
if res <= 0:
break
tmp = min(b, res)
res -= tmp
ans += tmp * a
print(ans)
| false
| 18.75
|
[
"+res = M",
"-res = M",
"-for v in X:",
"- ans += v[0] * min(v[1], res)",
"- res -= v[1]",
"+for a, b in X:",
"+ tmp = min(b, res)",
"+ res -= tmp",
"+ ans += tmp * a"
] | false
| 0.041884
| 0.058887
| 0.711269
|
[
"s996284831",
"s651640601"
] |
u091855288
|
p04006
|
python
|
s652494211
|
s327322097
| 797
| 315
| 10,536
| 10,536
|
Accepted
|
Accepted
| 60.48
|
import numpy as np
from copy import deepcopy
N, x = list(map(int,input().split()))
A = list(map(int,input().split()))
def myfunc(N, x, A):
B = deepcopy(np.array(A))
m = sum(B)
def apppop(A):
A.append(A[0])
A.pop(0)
for idx in range(1,N):
apppop(A)
np.fmin(B, A, out=B)
m = min(np.sum(B)+idx*x, m)
print(int(m))
myfunc(N, x, A)
|
import numpy as np
from copy import deepcopy
N, x = list(map(int,input().split()))
A = list(map(int,input().split()))
def myfunc(N, x, A):
A = np.array(A)
B = deepcopy(A)
m = sum(B)
for idx in range(1,N):
A = np.append(A, A[0])
A = np.delete(A, 0)
np.fmin(B, A, out=B)
m = min(np.sum(B)+idx*x, m)
print(int(m))
myfunc(N, x, A)
| 20
| 18
| 375
| 368
|
import numpy as np
from copy import deepcopy
N, x = list(map(int, input().split()))
A = list(map(int, input().split()))
def myfunc(N, x, A):
B = deepcopy(np.array(A))
m = sum(B)
def apppop(A):
A.append(A[0])
A.pop(0)
for idx in range(1, N):
apppop(A)
np.fmin(B, A, out=B)
m = min(np.sum(B) + idx * x, m)
print(int(m))
myfunc(N, x, A)
|
import numpy as np
from copy import deepcopy
N, x = list(map(int, input().split()))
A = list(map(int, input().split()))
def myfunc(N, x, A):
A = np.array(A)
B = deepcopy(A)
m = sum(B)
for idx in range(1, N):
A = np.append(A, A[0])
A = np.delete(A, 0)
np.fmin(B, A, out=B)
m = min(np.sum(B) + idx * x, m)
print(int(m))
myfunc(N, x, A)
| false
| 10
|
[
"- B = deepcopy(np.array(A))",
"+ A = np.array(A)",
"+ B = deepcopy(A)",
"-",
"- def apppop(A):",
"- A.append(A[0])",
"- A.pop(0)",
"-",
"- apppop(A)",
"+ A = np.append(A, A[0])",
"+ A = np.delete(A, 0)"
] | false
| 0.212143
| 0.184075
| 1.152485
|
[
"s652494211",
"s327322097"
] |
u094191970
|
p03473
|
python
|
s607340038
|
s545410546
| 19
| 17
| 3,060
| 2,940
|
Accepted
|
Accepted
| 10.53
|
print((48-int(eval(input()))))
|
m=int(eval(input()))
print((48-m))
| 1
| 2
| 22
| 27
|
print((48 - int(eval(input()))))
|
m = int(eval(input()))
print((48 - m))
| false
| 50
|
[
"-print((48 - int(eval(input()))))",
"+m = int(eval(input()))",
"+print((48 - m))"
] | false
| 0.045062
| 0.074497
| 0.604876
|
[
"s607340038",
"s545410546"
] |
u644907318
|
p02909
|
python
|
s169907836
|
s618620780
| 182
| 159
| 38,256
| 38,256
|
Accepted
|
Accepted
| 12.64
|
S = input().strip()
if S=="Sunny":
print("Cloudy")
elif S=="Cloudy":
print("Rainy")
elif S=="Rainy":
print("Sunny")
|
S = input().strip()
if S=="Sunny":
print("Cloudy")
elif S=="Cloudy":
print("Rainy")
else:
print("Sunny")
| 7
| 7
| 133
| 122
|
S = input().strip()
if S == "Sunny":
print("Cloudy")
elif S == "Cloudy":
print("Rainy")
elif S == "Rainy":
print("Sunny")
|
S = input().strip()
if S == "Sunny":
print("Cloudy")
elif S == "Cloudy":
print("Rainy")
else:
print("Sunny")
| false
| 0
|
[
"-elif S == \"Rainy\":",
"+else:"
] | false
| 0.091556
| 0.007113
| 12.871934
|
[
"s169907836",
"s618620780"
] |
u794544096
|
p02784
|
python
|
s829085324
|
s198108418
| 210
| 80
| 52,292
| 83,844
|
Accepted
|
Accepted
| 61.9
|
h , n = list(map(int, input().split()))
a = list(map(int, input().split()))
for i in range(n):
h -= a[i]
if h <= 0:
print('Yes')
else:
print('No')
|
h, n = list(map(int, input().split()))
a = list(map(int, input().split()))
if h <= sum(a):
print('Yes')
else:
print('No')
| 11
| 7
| 165
| 130
|
h, n = list(map(int, input().split()))
a = list(map(int, input().split()))
for i in range(n):
h -= a[i]
if h <= 0:
print("Yes")
else:
print("No")
|
h, n = list(map(int, input().split()))
a = list(map(int, input().split()))
if h <= sum(a):
print("Yes")
else:
print("No")
| false
| 36.363636
|
[
"-for i in range(n):",
"- h -= a[i]",
"-if h <= 0:",
"+if h <= sum(a):"
] | false
| 0.035879
| 0.036552
| 0.981565
|
[
"s829085324",
"s198108418"
] |
u645250356
|
p02924
|
python
|
s465409209
|
s310406601
| 180
| 145
| 38,384
| 77,256
|
Accepted
|
Accepted
| 19.44
|
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
import sys,bisect,math,itertools
sys.setrecursionlimit(10**8)
mod = 10**9+7
mod2 = 998244353
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpln(n): return list(int(sys.stdin.readline()) for i in range(n))
n = inp()
print((n*(n-1)//2))
|
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush
from bisect import bisect_left,bisect_right
import sys,math,itertools,fractions,pprint
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
n = inp()
print((n*(n-1)//2))
| 13
| 12
| 424
| 382
|
from collections import Counter, defaultdict, deque
from heapq import heappop, heappush, heapify
import sys, bisect, math, itertools
sys.setrecursionlimit(10**8)
mod = 10**9 + 7
mod2 = 998244353
INF = float("inf")
def inp():
return int(sys.stdin.readline())
def inpl():
return list(map(int, sys.stdin.readline().split()))
def inpln(n):
return list(int(sys.stdin.readline()) for i in range(n))
n = inp()
print((n * (n - 1) // 2))
|
from collections import Counter, defaultdict, deque
from heapq import heappop, heappush
from bisect import bisect_left, bisect_right
import sys, math, itertools, fractions, pprint
sys.setrecursionlimit(10**8)
mod = 10**9 + 7
INF = float("inf")
def inp():
return int(sys.stdin.readline())
def inpl():
return list(map(int, sys.stdin.readline().split()))
n = inp()
print((n * (n - 1) // 2))
| false
| 7.692308
|
[
"-from heapq import heappop, heappush, heapify",
"-import sys, bisect, math, itertools",
"+from heapq import heappop, heappush",
"+from bisect import bisect_left, bisect_right",
"+import sys, math, itertools, fractions, pprint",
"-mod2 = 998244353",
"-def inpln(n):",
"- return list(int(sys.stdin.readline()) for i in range(n))",
"-",
"-"
] | false
| 0.037505
| 0.035067
| 1.069518
|
[
"s465409209",
"s310406601"
] |
u936985471
|
p03634
|
python
|
s498379811
|
s288674409
| 689
| 453
| 50,348
| 50,072
|
Accepted
|
Accepted
| 34.25
|
# Kから各頂点への距離をメモする
# xからKの距離とyからKの距離を足したものが答え
import sys
readline = sys.stdin.readline
N = int(readline())
G = [[] for i in range(N)]
for i in range(N - 1):
a,b,c = list(map(int,readline().split()))
G[a-1].append((b-1,c))
G[b-1].append((a-1,c))
dist = [-1 for i in range(N)] # Kからの距離
Q,K = list(map(int,readline().split()))
dist[K - 1] = 0
from collections import deque
# 頂点、Kからの距離, 親
q = deque([[K - 1, 0, -1]])
while q:
v, d, parent = q.popleft()
dist[v] = d
for child in G[v]:
if child[0] == parent:
continue
q.append([child[0],d + child[1], v])
for i in range(Q):
x,y = list(map(int,readline().split()))
print((dist[x - 1] + dist[y - 1]))
|
import sys
readline = sys.stdin.readline
N = int(readline())
G = [[] for i in range(N)]
for i in range(N - 1):
a,b,c = list(map(int,readline().split()))
G[a - 1].append((b - 1, c))
G[b - 1].append((a - 1, c))
Q,K = list(map(int,readline().split()))
dist = [0] * N
stack = [(K - 1, -1, 0)]
while stack:
v,parent,cost = stack.pop()
dist[v] = cost
for child, c in G[v]:
if child == parent:
continue
stack.append((child, v, cost + c))
for i in range(Q):
x,y = list(map(int,readline().split()))
print((dist[x - 1] + dist[y - 1]))
| 32
| 26
| 690
| 571
|
# Kから各頂点への距離をメモする
# xからKの距離とyからKの距離を足したものが答え
import sys
readline = sys.stdin.readline
N = int(readline())
G = [[] for i in range(N)]
for i in range(N - 1):
a, b, c = list(map(int, readline().split()))
G[a - 1].append((b - 1, c))
G[b - 1].append((a - 1, c))
dist = [-1 for i in range(N)] # Kからの距離
Q, K = list(map(int, readline().split()))
dist[K - 1] = 0
from collections import deque
# 頂点、Kからの距離, 親
q = deque([[K - 1, 0, -1]])
while q:
v, d, parent = q.popleft()
dist[v] = d
for child in G[v]:
if child[0] == parent:
continue
q.append([child[0], d + child[1], v])
for i in range(Q):
x, y = list(map(int, readline().split()))
print((dist[x - 1] + dist[y - 1]))
|
import sys
readline = sys.stdin.readline
N = int(readline())
G = [[] for i in range(N)]
for i in range(N - 1):
a, b, c = list(map(int, readline().split()))
G[a - 1].append((b - 1, c))
G[b - 1].append((a - 1, c))
Q, K = list(map(int, readline().split()))
dist = [0] * N
stack = [(K - 1, -1, 0)]
while stack:
v, parent, cost = stack.pop()
dist[v] = cost
for child, c in G[v]:
if child == parent:
continue
stack.append((child, v, cost + c))
for i in range(Q):
x, y = list(map(int, readline().split()))
print((dist[x - 1] + dist[y - 1]))
| false
| 18.75
|
[
"-# Kから各頂点への距離をメモする",
"-# xからKの距離とyからKの距離を足したものが答え",
"-dist = [-1 for i in range(N)] # Kからの距離",
"-dist[K - 1] = 0",
"-from collections import deque",
"-",
"-# 頂点、Kからの距離, 親",
"-q = deque([[K - 1, 0, -1]])",
"-while q:",
"- v, d, parent = q.popleft()",
"- dist[v] = d",
"- for child in G[v]:",
"- if child[0] == parent:",
"+dist = [0] * N",
"+stack = [(K - 1, -1, 0)]",
"+while stack:",
"+ v, parent, cost = stack.pop()",
"+ dist[v] = cost",
"+ for child, c in G[v]:",
"+ if child == parent:",
"- q.append([child[0], d + child[1], v])",
"+ stack.append((child, v, cost + c))"
] | false
| 0.073023
| 0.040587
| 1.79916
|
[
"s498379811",
"s288674409"
] |
u301624971
|
p03574
|
python
|
s592477112
|
s963309884
| 30
| 24
| 3,188
| 3,316
|
Accepted
|
Accepted
| 20
|
import itertools
H, W = list(map(int, input().split()))
S = []
ans = []
for _ in range(H):
S.append(list(eval(input())))
ans.append(['#' for i in range(W)])
op =[]
for i in itertools.product([-1, 0, 1], repeat=2):
op.append(i)
for i, s1 in enumerate(S):
for j, s2 in enumerate(s1):
if(s2 == '.'):
counter = 0
for o in op:
if(i == 0 and o[0] == -1):
continue
elif(i == H-1 and o[0] == 1):
continue
elif(j == 0 and o[1] == -1):
continue
elif(j == W-1 and o[1] == 1):
continue
else:
if(S[i + o[0]][j + o[1]] == "#"):
counter += 1
ans[i][j] = str(counter)
for a in ans:
print((''.join(a)))
|
def myAnswer(H:int,W:int,S:list) -> None:
ans = [["#" for _ in range(W+2)]]
index = []
for i,s in enumerate(S):
tmp = ["#"]
for j,b in enumerate(s):
if(b == "."):
tmp.append(0)
else:
index.append([i+1,j+1])
tmp.append(b)
tmp.append("#")
ans.append(tmp)
ans.append(["#" for i in range(W+2)])
for i,j in index:
for n in range(i-1,i+2,1):
for m in range(j-1,j+2,1):
if(ans[n][m]!="#"):
ans[n][m] +=1
ans.pop(0)
ans.pop()
for a in ans:
a.pop(0)
a.pop(-1)
string = ""
for s in a:
string += str(s)
print(string)
def main():
H,W = list(map(int,input().split()))
S = [list(eval(input())) for _ in range(H)]
myAnswer(H,W,S[:])
if __name__ == '__main__':
main()
| 34
| 36
| 877
| 877
|
import itertools
H, W = list(map(int, input().split()))
S = []
ans = []
for _ in range(H):
S.append(list(eval(input())))
ans.append(["#" for i in range(W)])
op = []
for i in itertools.product([-1, 0, 1], repeat=2):
op.append(i)
for i, s1 in enumerate(S):
for j, s2 in enumerate(s1):
if s2 == ".":
counter = 0
for o in op:
if i == 0 and o[0] == -1:
continue
elif i == H - 1 and o[0] == 1:
continue
elif j == 0 and o[1] == -1:
continue
elif j == W - 1 and o[1] == 1:
continue
else:
if S[i + o[0]][j + o[1]] == "#":
counter += 1
ans[i][j] = str(counter)
for a in ans:
print(("".join(a)))
|
def myAnswer(H: int, W: int, S: list) -> None:
ans = [["#" for _ in range(W + 2)]]
index = []
for i, s in enumerate(S):
tmp = ["#"]
for j, b in enumerate(s):
if b == ".":
tmp.append(0)
else:
index.append([i + 1, j + 1])
tmp.append(b)
tmp.append("#")
ans.append(tmp)
ans.append(["#" for i in range(W + 2)])
for i, j in index:
for n in range(i - 1, i + 2, 1):
for m in range(j - 1, j + 2, 1):
if ans[n][m] != "#":
ans[n][m] += 1
ans.pop(0)
ans.pop()
for a in ans:
a.pop(0)
a.pop(-1)
string = ""
for s in a:
string += str(s)
print(string)
def main():
H, W = list(map(int, input().split()))
S = [list(eval(input())) for _ in range(H)]
myAnswer(H, W, S[:])
if __name__ == "__main__":
main()
| false
| 5.555556
|
[
"-import itertools",
"+def myAnswer(H: int, W: int, S: list) -> None:",
"+ ans = [[\"#\" for _ in range(W + 2)]]",
"+ index = []",
"+ for i, s in enumerate(S):",
"+ tmp = [\"#\"]",
"+ for j, b in enumerate(s):",
"+ if b == \".\":",
"+ tmp.append(0)",
"+ else:",
"+ index.append([i + 1, j + 1])",
"+ tmp.append(b)",
"+ tmp.append(\"#\")",
"+ ans.append(tmp)",
"+ ans.append([\"#\" for i in range(W + 2)])",
"+ for i, j in index:",
"+ for n in range(i - 1, i + 2, 1):",
"+ for m in range(j - 1, j + 2, 1):",
"+ if ans[n][m] != \"#\":",
"+ ans[n][m] += 1",
"+ ans.pop(0)",
"+ ans.pop()",
"+ for a in ans:",
"+ a.pop(0)",
"+ a.pop(-1)",
"+ string = \"\"",
"+ for s in a:",
"+ string += str(s)",
"+ print(string)",
"-H, W = list(map(int, input().split()))",
"-S = []",
"-ans = []",
"-for _ in range(H):",
"- S.append(list(eval(input())))",
"- ans.append([\"#\" for i in range(W)])",
"-op = []",
"-for i in itertools.product([-1, 0, 1], repeat=2):",
"- op.append(i)",
"-for i, s1 in enumerate(S):",
"- for j, s2 in enumerate(s1):",
"- if s2 == \".\":",
"- counter = 0",
"- for o in op:",
"- if i == 0 and o[0] == -1:",
"- continue",
"- elif i == H - 1 and o[0] == 1:",
"- continue",
"- elif j == 0 and o[1] == -1:",
"- continue",
"- elif j == W - 1 and o[1] == 1:",
"- continue",
"- else:",
"- if S[i + o[0]][j + o[1]] == \"#\":",
"- counter += 1",
"- ans[i][j] = str(counter)",
"-for a in ans:",
"- print((\"\".join(a)))",
"+",
"+def main():",
"+ H, W = list(map(int, input().split()))",
"+ S = [list(eval(input())) for _ in range(H)]",
"+ myAnswer(H, W, S[:])",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false
| 0.042255
| 0.045364
| 0.931476
|
[
"s592477112",
"s963309884"
] |
u078349616
|
p02762
|
python
|
s089428780
|
s418296916
| 1,417
| 1,127
| 105,076
| 15,008
|
Accepted
|
Accepted
| 20.47
|
from sys import setrecursionlimit
setrecursionlimit(2 * 10 ** 9)
N, M, K = list(map(int, input().split()))
AB = [list(map(int, input().split())) for _ in range(M)]
CD = [list(map(int, input().split())) for _ in range(K)]
f_G = [[] for _ in range(N)]
for a, b in AB:
a, b = a-1, b-1
f_G[a].append(b)
f_G[b].append(a)
b_G = [[] for _ in range(N)]
for c, d in CD:
c, d = c-1, d-1
b_G[c].append(d)
b_G[d].append(c)
def dfs(v):
if visited[v]:
return
visited[v] = True
for nv in f_G[v]:
s.add(nv)
dfs(nv)
ans = [0] * N
visited = [False] * N
for i in range(N):
if not visited[i]:
s = set()
dfs(i)
l = len(s)
for u in s:
ans[u] = l - 1
ans[u] -= len(set(f_G[u]) & s)
ans[u] -= len(set(b_G[u]) & s)
print((*ans))
|
import sys
sys.setrecursionlimit(10 ** 9)
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
N, M, K = list(map(int, input().split()))
uf = UnionFind(N)
FG = [0] * N
BG = [0] * N
for _ in range(M):
a, b = list(map(int, input().split()))
a, b = a-1, b-1
uf.union(a, b)
FG[a] += 1
FG[b] += 1
for _ in range(K):
c, d = list(map(int, input().split()))
c, d = c-1, d-1
if uf.same(c, d):
BG[c] += 1
BG[d] += 1
ans = []
for i in range(N):
ans.append(uf.size(i) - FG[i] - BG[i] - 1)
print((*ans))
| 41
| 73
| 810
| 1,546
|
from sys import setrecursionlimit
setrecursionlimit(2 * 10**9)
N, M, K = list(map(int, input().split()))
AB = [list(map(int, input().split())) for _ in range(M)]
CD = [list(map(int, input().split())) for _ in range(K)]
f_G = [[] for _ in range(N)]
for a, b in AB:
a, b = a - 1, b - 1
f_G[a].append(b)
f_G[b].append(a)
b_G = [[] for _ in range(N)]
for c, d in CD:
c, d = c - 1, d - 1
b_G[c].append(d)
b_G[d].append(c)
def dfs(v):
if visited[v]:
return
visited[v] = True
for nv in f_G[v]:
s.add(nv)
dfs(nv)
ans = [0] * N
visited = [False] * N
for i in range(N):
if not visited[i]:
s = set()
dfs(i)
l = len(s)
for u in s:
ans[u] = l - 1
ans[u] -= len(set(f_G[u]) & s)
ans[u] -= len(set(b_G[u]) & s)
print((*ans))
|
import sys
sys.setrecursionlimit(10**9)
class UnionFind:
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return "\n".join("{}: {}".format(r, self.members(r)) for r in self.roots())
N, M, K = list(map(int, input().split()))
uf = UnionFind(N)
FG = [0] * N
BG = [0] * N
for _ in range(M):
a, b = list(map(int, input().split()))
a, b = a - 1, b - 1
uf.union(a, b)
FG[a] += 1
FG[b] += 1
for _ in range(K):
c, d = list(map(int, input().split()))
c, d = c - 1, d - 1
if uf.same(c, d):
BG[c] += 1
BG[d] += 1
ans = []
for i in range(N):
ans.append(uf.size(i) - FG[i] - BG[i] - 1)
print((*ans))
| false
| 43.835616
|
[
"-from sys import setrecursionlimit",
"+import sys",
"-setrecursionlimit(2 * 10**9)",
"-N, M, K = list(map(int, input().split()))",
"-AB = [list(map(int, input().split())) for _ in range(M)]",
"-CD = [list(map(int, input().split())) for _ in range(K)]",
"-f_G = [[] for _ in range(N)]",
"-for a, b in AB:",
"- a, b = a - 1, b - 1",
"- f_G[a].append(b)",
"- f_G[b].append(a)",
"-b_G = [[] for _ in range(N)]",
"-for c, d in CD:",
"- c, d = c - 1, d - 1",
"- b_G[c].append(d)",
"- b_G[d].append(c)",
"+sys.setrecursionlimit(10**9)",
"-def dfs(v):",
"- if visited[v]:",
"- return",
"- visited[v] = True",
"- for nv in f_G[v]:",
"- s.add(nv)",
"- dfs(nv)",
"+class UnionFind:",
"+ def __init__(self, n):",
"+ self.n = n",
"+ self.parents = [-1] * n",
"+",
"+ def find(self, x):",
"+ if self.parents[x] < 0:",
"+ return x",
"+ else:",
"+ self.parents[x] = self.find(self.parents[x])",
"+ return self.parents[x]",
"+",
"+ def union(self, x, y):",
"+ x = self.find(x)",
"+ y = self.find(y)",
"+ if x == y:",
"+ return",
"+ if self.parents[x] > self.parents[y]:",
"+ x, y = y, x",
"+ self.parents[x] += self.parents[y]",
"+ self.parents[y] = x",
"+",
"+ def size(self, x):",
"+ return -self.parents[self.find(x)]",
"+",
"+ def same(self, x, y):",
"+ return self.find(x) == self.find(y)",
"+",
"+ def members(self, x):",
"+ root = self.find(x)",
"+ return [i for i in range(self.n) if self.find(i) == root]",
"+",
"+ def roots(self):",
"+ return [i for i, x in enumerate(self.parents) if x < 0]",
"+",
"+ def group_count(self):",
"+ return len(self.roots())",
"+",
"+ def all_group_members(self):",
"+ return {r: self.members(r) for r in self.roots()}",
"+",
"+ def __str__(self):",
"+ return \"\\n\".join(\"{}: {}\".format(r, self.members(r)) for r in self.roots())",
"-ans = [0] * N",
"-visited = [False] * N",
"+N, M, K = list(map(int, input().split()))",
"+uf = UnionFind(N)",
"+FG = [0] * N",
"+BG = [0] * N",
"+for _ in range(M):",
"+ a, b = list(map(int, input().split()))",
"+ a, b = a - 1, b - 1",
"+ uf.union(a, b)",
"+ FG[a] += 1",
"+ FG[b] += 1",
"+for _ in range(K):",
"+ c, d = list(map(int, input().split()))",
"+ c, d = c - 1, d - 1",
"+ if uf.same(c, d):",
"+ BG[c] += 1",
"+ BG[d] += 1",
"+ans = []",
"- if not visited[i]:",
"- s = set()",
"- dfs(i)",
"- l = len(s)",
"- for u in s:",
"- ans[u] = l - 1",
"- ans[u] -= len(set(f_G[u]) & s)",
"- ans[u] -= len(set(b_G[u]) & s)",
"+ ans.append(uf.size(i) - FG[i] - BG[i] - 1)"
] | false
| 0.043865
| 0.05273
| 0.831888
|
[
"s089428780",
"s418296916"
] |
u347640436
|
p02990
|
python
|
s150105692
|
s813270707
| 826
| 44
| 103,852
| 9,172
|
Accepted
|
Accepted
| 94.67
|
# パスカルの三角形
N, K = map(int, input().split())
m = 1000000007
n = max(K, N - K + 1)
c = [[0] * (n + 1) for _ in range(n + 1)]
c[0][0] = 1
for i in range(1, n + 1):
c[i][0] = 1
for j in range(1, i + 1):
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % m
result = []
for i in range(1, K + 1):
result.append(c[K - 1][i - 1] * c[N - K + 1][i] % m)
#print('\n'.join(str(i) for i in result))
print(*result, sep='\n')
|
# フェルマーの小定理
N, K = list(map(int, input().split()))
m = 1000000007
def make_factorial_table(n):
result = [0] * (n + 1)
result[0] = 1
for i in range(1, n + 1):
result[i] = result[i - 1] * i % m
return result
def mcomb(n, k):
if n == 0 and k == 0:
return 1
if n < k or k < 0:
return 0
return fac[n] * pow(fac[n - k], m - 2, m) * pow(fac[k], m - 2, m) % m
n = max(K, N - K + 1)
fac = make_factorial_table(n)
result = []
for i in range(1, K + 1):
result.append(mcomb(K - 1, i - 1) * mcomb(N - K + 1, i) % m)
print(('\n'.join(str(i) for i in result)))
#print(*result, sep='\n')
| 18
| 30
| 443
| 657
|
# パスカルの三角形
N, K = map(int, input().split())
m = 1000000007
n = max(K, N - K + 1)
c = [[0] * (n + 1) for _ in range(n + 1)]
c[0][0] = 1
for i in range(1, n + 1):
c[i][0] = 1
for j in range(1, i + 1):
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % m
result = []
for i in range(1, K + 1):
result.append(c[K - 1][i - 1] * c[N - K + 1][i] % m)
# print('\n'.join(str(i) for i in result))
print(*result, sep="\n")
|
# フェルマーの小定理
N, K = list(map(int, input().split()))
m = 1000000007
def make_factorial_table(n):
result = [0] * (n + 1)
result[0] = 1
for i in range(1, n + 1):
result[i] = result[i - 1] * i % m
return result
def mcomb(n, k):
if n == 0 and k == 0:
return 1
if n < k or k < 0:
return 0
return fac[n] * pow(fac[n - k], m - 2, m) * pow(fac[k], m - 2, m) % m
n = max(K, N - K + 1)
fac = make_factorial_table(n)
result = []
for i in range(1, K + 1):
result.append(mcomb(K - 1, i - 1) * mcomb(N - K + 1, i) % m)
print(("\n".join(str(i) for i in result)))
# print(*result, sep='\n')
| false
| 40
|
[
"-# パスカルの三角形",
"-N, K = map(int, input().split())",
"+# フェルマーの小定理",
"+N, K = list(map(int, input().split()))",
"+",
"+",
"+def make_factorial_table(n):",
"+ result = [0] * (n + 1)",
"+ result[0] = 1",
"+ for i in range(1, n + 1):",
"+ result[i] = result[i - 1] * i % m",
"+ return result",
"+",
"+",
"+def mcomb(n, k):",
"+ if n == 0 and k == 0:",
"+ return 1",
"+ if n < k or k < 0:",
"+ return 0",
"+ return fac[n] * pow(fac[n - k], m - 2, m) * pow(fac[k], m - 2, m) % m",
"+",
"+",
"-c = [[0] * (n + 1) for _ in range(n + 1)]",
"-c[0][0] = 1",
"-for i in range(1, n + 1):",
"- c[i][0] = 1",
"- for j in range(1, i + 1):",
"- c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % m",
"+fac = make_factorial_table(n)",
"- result.append(c[K - 1][i - 1] * c[N - K + 1][i] % m)",
"-# print('\\n'.join(str(i) for i in result))",
"-print(*result, sep=\"\\n\")",
"+ result.append(mcomb(K - 1, i - 1) * mcomb(N - K + 1, i) % m)",
"+print((\"\\n\".join(str(i) for i in result)))",
"+# print(*result, sep='\\n')"
] | false
| 0.422343
| 0.036845
| 11.462613
|
[
"s150105692",
"s813270707"
] |
u285443936
|
p03147
|
python
|
s646057590
|
s196649742
| 25
| 20
| 3,188
| 3,064
|
Accepted
|
Accepted
| 20
|
N = int(eval(input()))
h = list(map(int, input().split()))
ans = 0
def water(x):
global ans
# print(x, ans)
if any(x) == False:
# print(0)
return
else:
# print(1)
if 0 in x:
# print(2)
x1, x2 = x[0:x.index(0)], x[x.index(0)+1:]
water(x1)
water(x2)
else:
# print(3)
ans += min(x)
x = list([i-min(x) for i in x])
water(x)
return
water(h)
print(ans)
|
N = int(eval(input()))
h = [int(i) for i in input().split()]
h.append(0)
ans = 0
while any(h):
l,r = 0, 0
for i in range(N):
if h[i] == 0 and h[i+1] != 0:
l = i+1
if (h[i] != 0 and h[i+1] == 0):
r = i+1
minh = min(h[l:r])
ans += minh
for j in range(l,r):
h[j] -= minh
print(ans)
| 28
| 17
| 457
| 339
|
N = int(eval(input()))
h = list(map(int, input().split()))
ans = 0
def water(x):
global ans
# print(x, ans)
if any(x) == False:
# print(0)
return
else:
# print(1)
if 0 in x:
# print(2)
x1, x2 = x[0 : x.index(0)], x[x.index(0) + 1 :]
water(x1)
water(x2)
else:
# print(3)
ans += min(x)
x = list([i - min(x) for i in x])
water(x)
return
water(h)
print(ans)
|
N = int(eval(input()))
h = [int(i) for i in input().split()]
h.append(0)
ans = 0
while any(h):
l, r = 0, 0
for i in range(N):
if h[i] == 0 and h[i + 1] != 0:
l = i + 1
if h[i] != 0 and h[i + 1] == 0:
r = i + 1
minh = min(h[l:r])
ans += minh
for j in range(l, r):
h[j] -= minh
print(ans)
| false
| 39.285714
|
[
"-h = list(map(int, input().split()))",
"+h = [int(i) for i in input().split()]",
"+h.append(0)",
"-",
"-",
"-def water(x):",
"- global ans",
"- # print(x, ans)",
"- if any(x) == False:",
"- # print(0)",
"- return",
"- else:",
"- # print(1)",
"- if 0 in x:",
"- # print(2)",
"- x1, x2 = x[0 : x.index(0)], x[x.index(0) + 1 :]",
"- water(x1)",
"- water(x2)",
"- else:",
"- # print(3)",
"- ans += min(x)",
"- x = list([i - min(x) for i in x])",
"- water(x)",
"- return",
"-",
"-",
"-water(h)",
"+while any(h):",
"+ l, r = 0, 0",
"+ for i in range(N):",
"+ if h[i] == 0 and h[i + 1] != 0:",
"+ l = i + 1",
"+ if h[i] != 0 and h[i + 1] == 0:",
"+ r = i + 1",
"+ minh = min(h[l:r])",
"+ ans += minh",
"+ for j in range(l, r):",
"+ h[j] -= minh"
] | false
| 0.045903
| 0.044642
| 1.028248
|
[
"s646057590",
"s196649742"
] |
u880480312
|
p02814
|
python
|
s046228029
|
s251748600
| 233
| 204
| 16,348
| 16,348
|
Accepted
|
Accepted
| 12.45
|
import math
import fractions
from functools import reduce
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
a=[t//2 for t in a] # リストの要素を全て2で割る
def lcm_base(x, y):
return (x * y) // fractions.gcd(x, y)
def lcm_list(numbers): # 最小公倍数を求める
return reduce(lcm_base, numbers, 1)
def num_dev2(x): # 2で割り切れる回数をカウント
return format(x, 'b')[::-1].find('1')
lcm = lcm_list(a)
q = m // lcm # mは最小公倍数で何回割れるか
count = 0
dev2 = num_dev2(a[0])
for i in range(1, n):
if dev2 != num_dev2(a[i]): # リストの全ての要素の、2で割れる回数は等しいか？
count += 1
break
if count != 0:
print((0))
else:
print((math.ceil(q/2)))
|
import math
import fractions
from functools import reduce
n, m = list(map(int,input().split()))
a = list(map(int,input().split()))
a = [t // 2 for t in a]#リストの要素すべてを2で割る
def lcm_base(x, y):
return (x * y)//fractions.gcd(x,y)
def lcm_list(numbers): #最小公倍数を求める
return reduce(lcm_base, numbers, 1)
def num_dev2(x):
return bin(x)[::-1].find("1") #２で割り切れる回数を確認
lcm = lcm_list(a)
q = m//lcm #mは最小公倍数で何回割れるか
count = 0
dev2 = num_dev2(a[0])
for i in range(1,n):
if dev2 != num_dev2(a[i]):#リストのすべての要素の２で割れる回数は等しいか
count += 1
break
if count != 0:
print((0))
else:
print((math.ceil(q/2)))
| 30
| 30
| 669
| 642
|
import math
import fractions
from functools import reduce
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
a = [t // 2 for t in a] # リストの要素を全て2で割る
def lcm_base(x, y):
return (x * y) // fractions.gcd(x, y)
def lcm_list(numbers): # 最小公倍数を求める
return reduce(lcm_base, numbers, 1)
def num_dev2(x): # 2で割り切れる回数をカウント
return format(x, "b")[::-1].find("1")
lcm = lcm_list(a)
q = m // lcm # mは最小公倍数で何回割れるか
count = 0
dev2 = num_dev2(a[0])
for i in range(1, n):
if dev2 != num_dev2(a[i]): # リストの全ての要素の、2で割れる回数は等しいか？
count += 1
break
if count != 0:
print((0))
else:
print((math.ceil(q / 2)))
|
import math
import fractions
from functools import reduce
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
a = [t // 2 for t in a] # リストの要素すべてを2で割る
def lcm_base(x, y):
return (x * y) // fractions.gcd(x, y)
def lcm_list(numbers): # 最小公倍数を求める
return reduce(lcm_base, numbers, 1)
def num_dev2(x):
return bin(x)[::-1].find("1") # ２で割り切れる回数を確認
lcm = lcm_list(a)
q = m // lcm # mは最小公倍数で何回割れるか
count = 0
dev2 = num_dev2(a[0])
for i in range(1, n):
if dev2 != num_dev2(a[i]): # リストのすべての要素の２で割れる回数は等しいか
count += 1
break
if count != 0:
print((0))
else:
print((math.ceil(q / 2)))
| false
| 0
|
[
"-a = [t // 2 for t in a] # リストの要素を全て2で割る",
"+a = [t // 2 for t in a] # リストの要素すべてを2で割る",
"-def num_dev2(x): # 2で割り切れる回数をカウント",
"- return format(x, \"b\")[::-1].find(\"1\")",
"+def num_dev2(x):",
"+ return bin(x)[::-1].find(\"1\") # ２で割り切れる回数を確認",
"- if dev2 != num_dev2(a[i]): # リストの全ての要素の、2で割れる回数は等しいか？",
"+ if dev2 != num_dev2(a[i]): # リストのすべての要素の２で割れる回数は等しいか"
] | false
| 0.055845
| 0.050014
| 1.116589
|
[
"s046228029",
"s251748600"
] |
u940139461
|
p02972
|
python
|
s598534229
|
s153268350
| 991
| 794
| 20,536
| 20,532
|
Accepted
|
Accepted
| 19.88
|
N = int(eval(input()))
A = list(map(int, input().split()))
ans =[]
for _ in range(N):
ans.append(-1)
for i in range(1, N + 1)[::-1]:
C = i*2
BALL = A[i-1]
while C <= N:
BALL = BALL ^ ans[C-1]
C += i
ans[i-1] = BALL
print((ans.count(1)))
ans2 = []
for i in range(N):
if ans[i] == 1:
ans2.append(i+1)
L=[str(a) for a in ans2]
L=" ".join(L)
print(L)
|
n = int(eval(input()))
nums = list(map(int, input().split()))
ans = []
for _ in range(n):
ans.append(-1)
for i in range(1, n + 1)[::-1]:
C = i*2
BALL = nums[i-1]
while C <= n:
BALL = BALL ^ ans[C-1]
C += i
ans[i-1] = BALL
print((ans.count(1)))
ans2 = []
for i in range(n):
if ans[i] == 1:
ans2.append(i+1)
L=[str(a) for a in ans2]
L=" ".join(L)
print(L)
| 24
| 24
| 391
| 398
|
N = int(eval(input()))
A = list(map(int, input().split()))
ans = []
for _ in range(N):
ans.append(-1)
for i in range(1, N + 1)[::-1]:
C = i * 2
BALL = A[i - 1]
while C <= N:
BALL = BALL ^ ans[C - 1]
C += i
ans[i - 1] = BALL
print((ans.count(1)))
ans2 = []
for i in range(N):
if ans[i] == 1:
ans2.append(i + 1)
L = [str(a) for a in ans2]
L = " ".join(L)
print(L)
|
n = int(eval(input()))
nums = list(map(int, input().split()))
ans = []
for _ in range(n):
ans.append(-1)
for i in range(1, n + 1)[::-1]:
C = i * 2
BALL = nums[i - 1]
while C <= n:
BALL = BALL ^ ans[C - 1]
C += i
ans[i - 1] = BALL
print((ans.count(1)))
ans2 = []
for i in range(n):
if ans[i] == 1:
ans2.append(i + 1)
L = [str(a) for a in ans2]
L = " ".join(L)
print(L)
| false
| 0
|
[
"-N = int(eval(input()))",
"-A = list(map(int, input().split()))",
"+n = int(eval(input()))",
"+nums = list(map(int, input().split()))",
"-for _ in range(N):",
"+for _ in range(n):",
"-for i in range(1, N + 1)[::-1]:",
"+for i in range(1, n + 1)[::-1]:",
"- BALL = A[i - 1]",
"- while C <= N:",
"+ BALL = nums[i - 1]",
"+ while C <= n:",
"-for i in range(N):",
"+for i in range(n):"
] | false
| 0.077291
| 0.048047
| 1.608668
|
[
"s598534229",
"s153268350"
] |
u566428756
|
p02713
|
python
|
s566263987
|
s688873800
| 1,430
| 968
| 9,232
| 9,456
|
Accepted
|
Accepted
| 32.31
|
import math
import sys
read_=sys.stdin.buffer.readline
K=int(read_())
ans=0
for a in range(1,K+1):
for b in range(1,K+1):
x=math.gcd(a,b)
for c in range(1,K+1):
ans+=math.gcd(x,c)
print(ans)
|
from math import gcd
import sys
read=sys.stdin.buffer.readline
K=int(read())
l=[[0]*(K+1) for _ in range(K+1)]
for i in range(1,K+1):
for j in range(i,K+1):
x=gcd(i,j)
l[i][j],l[j][i]=x,x
ans=0
for a in range(1,K+1):
for b in range(1,K+1):
x=l[a][b]
for c in range(1,K+1):
ans+=l[x][c]
print(ans)
| 12
| 19
| 235
| 370
|
import math
import sys
read_ = sys.stdin.buffer.readline
K = int(read_())
ans = 0
for a in range(1, K + 1):
for b in range(1, K + 1):
x = math.gcd(a, b)
for c in range(1, K + 1):
ans += math.gcd(x, c)
print(ans)
|
from math import gcd
import sys
read = sys.stdin.buffer.readline
K = int(read())
l = [[0] * (K + 1) for _ in range(K + 1)]
for i in range(1, K + 1):
for j in range(i, K + 1):
x = gcd(i, j)
l[i][j], l[j][i] = x, x
ans = 0
for a in range(1, K + 1):
for b in range(1, K + 1):
x = l[a][b]
for c in range(1, K + 1):
ans += l[x][c]
print(ans)
| false
| 36.842105
|
[
"-import math",
"+from math import gcd",
"-read_ = sys.stdin.buffer.readline",
"-K = int(read_())",
"+read = sys.stdin.buffer.readline",
"+K = int(read())",
"+l = [[0] * (K + 1) for _ in range(K + 1)]",
"+for i in range(1, K + 1):",
"+ for j in range(i, K + 1):",
"+ x = gcd(i, j)",
"+ l[i][j], l[j][i] = x, x",
"- x = math.gcd(a, b)",
"+ x = l[a][b]",
"- ans += math.gcd(x, c)",
"+ ans += l[x][c]"
] | false
| 0.105083
| 0.136483
| 0.769936
|
[
"s566263987",
"s688873800"
] |
u893063840
|
p03625
|
python
|
s337920536
|
s808979297
| 164
| 90
| 22,436
| 18,600
|
Accepted
|
Accepted
| 45.12
|
# -*- coding: utf-8 -*-
from collections import Counter
n = int(eval(input()))
a = list(map(int, input().split()))
c = Counter(a)
li = sorted(list(c.items()), key=lambda x: x[0], reverse=True)
cands = []
for num, cnt in li:
if cnt >= 4:
cands += [num, num]
elif cnt >= 2:
cands += [num]
cands += [0, 0]
ans = cands[0] * cands[1]
print(ans)
|
# -*- coding: utf-8 -*-
from collections import Counter
n = int(eval(input()))
a = list(map(int, input().split()))
pair = [0, 0]
c = Counter(a)
for num, cnt in list(c.items()):
pair += [num] * (cnt // 2)
pair.sort(reverse=True)
ans = pair[0] * pair[1]
print(ans)
| 20
| 16
| 376
| 275
|
# -*- coding: utf-8 -*-
from collections import Counter
n = int(eval(input()))
a = list(map(int, input().split()))
c = Counter(a)
li = sorted(list(c.items()), key=lambda x: x[0], reverse=True)
cands = []
for num, cnt in li:
if cnt >= 4:
cands += [num, num]
elif cnt >= 2:
cands += [num]
cands += [0, 0]
ans = cands[0] * cands[1]
print(ans)
|
# -*- coding: utf-8 -*-
from collections import Counter
n = int(eval(input()))
a = list(map(int, input().split()))
pair = [0, 0]
c = Counter(a)
for num, cnt in list(c.items()):
pair += [num] * (cnt // 2)
pair.sort(reverse=True)
ans = pair[0] * pair[1]
print(ans)
| false
| 20
|
[
"+pair = [0, 0]",
"-li = sorted(list(c.items()), key=lambda x: x[0], reverse=True)",
"-cands = []",
"-for num, cnt in li:",
"- if cnt >= 4:",
"- cands += [num, num]",
"- elif cnt >= 2:",
"- cands += [num]",
"-cands += [0, 0]",
"-ans = cands[0] * cands[1]",
"+for num, cnt in list(c.items()):",
"+ pair += [num] * (cnt // 2)",
"+pair.sort(reverse=True)",
"+ans = pair[0] * pair[1]"
] | false
| 0.09216
| 0.062828
| 1.466853
|
[
"s337920536",
"s808979297"
] |
u191829404
|
p03031
|
python
|
s525032334
|
s476537823
| 229
| 32
| 42,948
| 3,668
|
Accepted
|
Accepted
| 86.03
|
# abcde s=input() s='abcde'
# abcde s=list(input()) s=['a', 'b', 'c', 'd', 'e']
# 5(1つだけ) a=int(input()) a=5
# 1 2 | x,y = s_inpl() | x=1,y=2
# 1 2 3 4 5 ... n li = input().split() li=['1','2','3',...,'n']
# 1 2 3 4 5 ... n li = inpl() li=[1,2,3,4,5,...,n]
# FFFTFTTFF li = input().split('T') li=['FFF', 'F', '', 'FF']
# INPUT
# 3
# hoge
# foo
# bar
# ANSWER
# n=int(input())
# string_list=[input() for i in range(n)]
import math
import copy
from collections import defaultdict
from collections import Counter
from collections import deque
# 直積 A={a, b, c}, B={d, e}:のとき，A×B={(a,d),(a,e),(b,d),(b,e),(c,d),(c,e)}: product(A, B)
from itertools import product
# 階乗 P!: permutations(seq), 順列 {}_len(seq) P_n: permutations(seq, n)
from itertools import permutations
# 組み合わせ {}_len(seq) C_n: combinations(seq, n)
from itertools import combinations
from bisect import bisect_left, bisect_right
# import numpy as np
def inside(y, x, H, W):
return 0 <= y < H and 0 <= x < W
# 四方向: 右, 下, 左, 上
dy = [0, -1, 0, 1]
dx = [1, 0, -1, 0]
def i_inpl(): return int(eval(input()))
def s_inpl(): return list(map(int,input().split()))
def l_inpl(): return list(map(int, input().split()))
INF = float("inf")
############
############
############
N, M = s_inpl()
ks = []
for _ in range(M):
k = l_inpl()
ks.append(k[1:])
ps = l_inpl()
cnt = 0
for i in range(2**N):
on_ss = []
for j in range(N):
if ((i>>j) & 1):
on_ss.append(j+1)
# print("JJJ")
flag = True
for k, p in zip(ks, ps):
if len(set(k)&set(on_ss)) % 2 != p:
flag = False
break
if flag:
cnt += 1
print(cnt)
|
import math
import copy
from operator import mul
from functools import reduce
from collections import defaultdict
from collections import Counter
from collections import deque
# 直積 A={a, b, c}, B={d, e}:のとき，A×B={(a,d),(a,e),(b,d),(b,e),(c,d),(c,e)}: product(A, B)
from itertools import product
# 階乗 P!: permutations(seq), 順列 {}_len(seq) P_n: permutations(seq, n)
from itertools import permutations
# 組み合わせ {}_len(seq) C_n: combinations(seq, n)
from itertools import combinations
from bisect import bisect_left, bisect_right
# import numpy as np
def inside(y, x, H, W):
return 0 <= y < H and 0 <= x < W
# 四方向: 右, 下, 左, 上
dy = [0, -1, 0, 1]
dx = [1, 0, -1, 0]
def i_inpl(): return int(eval(input()))
def l_inpl(): return list(map(int, input().split()))
INF = float("inf")
######
# URL: http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ALDS1_5_A&lang=ja
######
def main():
N, M = l_inpl()
d = {}
for i in range(M):
k = [int(j)-1 for j in input().split(" ")]
d[i] = k[1:]
p = [int(i) for i in input().split(" ")]
ans = 0
for i in range(2 ** N):
tmp = []
for j in range(N):
if ((i >> j) & 1):
tmp.append(j)
flag = True
for idx, k in list(d.items()):
cnt = 0
for ki in k:
if ki in tmp:
cnt += 1
if cnt % 2 != p[idx]:
flag = False
break
if flag:
ans += 1
print(ans)
if __name__ == "__main__":
main()
| 70
| 65
| 1,713
| 1,624
|
# abcde s=input() s='abcde'
# abcde s=list(input()) s=['a', 'b', 'c', 'd', 'e']
# 5(1つだけ) a=int(input()) a=5
# 1 2 | x,y = s_inpl() | x=1,y=2
# 1 2 3 4 5 ... n li = input().split() li=['1','2','3',...,'n']
# 1 2 3 4 5 ... n li = inpl() li=[1,2,3,4,5,...,n]
# FFFTFTTFF li = input().split('T') li=['FFF', 'F', '', 'FF']
# INPUT
# 3
# hoge
# foo
# bar
# ANSWER
# n=int(input())
# string_list=[input() for i in range(n)]
import math
import copy
from collections import defaultdict
from collections import Counter
from collections import deque
# 直積 A={a, b, c}, B={d, e}:のとき，A×B={(a,d),(a,e),(b,d),(b,e),(c,d),(c,e)}: product(A, B)
from itertools import product
# 階乗 P!: permutations(seq), 順列 {}_len(seq) P_n: permutations(seq, n)
from itertools import permutations
# 組み合わせ {}_len(seq) C_n: combinations(seq, n)
from itertools import combinations
from bisect import bisect_left, bisect_right
# import numpy as np
def inside(y, x, H, W):
return 0 <= y < H and 0 <= x < W
# 四方向: 右, 下, 左, 上
dy = [0, -1, 0, 1]
dx = [1, 0, -1, 0]
def i_inpl():
return int(eval(input()))
def s_inpl():
return list(map(int, input().split()))
def l_inpl():
return list(map(int, input().split()))
INF = float("inf")
############
############
############
N, M = s_inpl()
ks = []
for _ in range(M):
k = l_inpl()
ks.append(k[1:])
ps = l_inpl()
cnt = 0
for i in range(2**N):
on_ss = []
for j in range(N):
if (i >> j) & 1:
on_ss.append(j + 1)
# print("JJJ")
flag = True
for k, p in zip(ks, ps):
if len(set(k) & set(on_ss)) % 2 != p:
flag = False
break
if flag:
cnt += 1
print(cnt)
|
import math
import copy
from operator import mul
from functools import reduce
from collections import defaultdict
from collections import Counter
from collections import deque
# 直積 A={a, b, c}, B={d, e}:のとき，A×B={(a,d),(a,e),(b,d),(b,e),(c,d),(c,e)}: product(A, B)
from itertools import product
# 階乗 P!: permutations(seq), 順列 {}_len(seq) P_n: permutations(seq, n)
from itertools import permutations
# 組み合わせ {}_len(seq) C_n: combinations(seq, n)
from itertools import combinations
from bisect import bisect_left, bisect_right
# import numpy as np
def inside(y, x, H, W):
return 0 <= y < H and 0 <= x < W
# 四方向: 右, 下, 左, 上
dy = [0, -1, 0, 1]
dx = [1, 0, -1, 0]
def i_inpl():
return int(eval(input()))
def l_inpl():
return list(map(int, input().split()))
INF = float("inf")
######
# URL: http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ALDS1_5_A&lang=ja
######
def main():
N, M = l_inpl()
d = {}
for i in range(M):
k = [int(j) - 1 for j in input().split(" ")]
d[i] = k[1:]
p = [int(i) for i in input().split(" ")]
ans = 0
for i in range(2**N):
tmp = []
for j in range(N):
if (i >> j) & 1:
tmp.append(j)
flag = True
for idx, k in list(d.items()):
cnt = 0
for ki in k:
if ki in tmp:
cnt += 1
if cnt % 2 != p[idx]:
flag = False
break
if flag:
ans += 1
print(ans)
if __name__ == "__main__":
main()
| false
| 7.142857
|
[
"-# abcde\ts=input()\ts='abcde'",
"-# abcde\ts=list(input())\ts=['a', 'b', 'c', 'd', 'e']",
"-# 5(1つだけ)\ta=int(input())\ta=5",
"-# 1 2\t| x,y = s_inpl() |\tx=1,y=2",
"-# 1 2 3 4 5 ... n \tli = input().split()\tli=['1','2','3',...,'n']",
"-# 1 2 3 4 5 ... n \tli = inpl()\tli=[1,2,3,4,5,...,n]",
"-# FFFTFTTFF \tli = input().split('T')\tli=['FFF', 'F', '', 'FF']",
"-# INPUT",
"-# 3",
"-# hoge",
"-# foo",
"-# bar",
"-# ANSWER",
"-# n=int(input())",
"-# string_list=[input() for i in range(n)]",
"+from operator import mul",
"+from functools import reduce",
"-def s_inpl():",
"- return list(map(int, input().split()))",
"-",
"-",
"-############",
"-############",
"-############",
"-N, M = s_inpl()",
"-ks = []",
"-for _ in range(M):",
"- k = l_inpl()",
"- ks.append(k[1:])",
"-ps = l_inpl()",
"-cnt = 0",
"-for i in range(2**N):",
"- on_ss = []",
"- for j in range(N):",
"- if (i >> j) & 1:",
"- on_ss.append(j + 1)",
"- # print(\"JJJ\")",
"- flag = True",
"- for k, p in zip(ks, ps):",
"- if len(set(k) & set(on_ss)) % 2 != p:",
"- flag = False",
"- break",
"- if flag:",
"- cnt += 1",
"-print(cnt)",
"+######",
"+# URL: http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ALDS1_5_A&lang=ja",
"+######",
"+def main():",
"+ N, M = l_inpl()",
"+ d = {}",
"+ for i in range(M):",
"+ k = [int(j) - 1 for j in input().split(\" \")]",
"+ d[i] = k[1:]",
"+ p = [int(i) for i in input().split(\" \")]",
"+ ans = 0",
"+ for i in range(2**N):",
"+ tmp = []",
"+ for j in range(N):",
"+ if (i >> j) & 1:",
"+ tmp.append(j)",
"+ flag = True",
"+ for idx, k in list(d.items()):",
"+ cnt = 0",
"+ for ki in k:",
"+ if ki in tmp:",
"+ cnt += 1",
"+ if cnt % 2 != p[idx]:",
"+ flag = False",
"+ break",
"+ if flag:",
"+ ans += 1",
"+ print(ans)",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false
| 0.061954
| 0.08795
| 0.704424
|
[
"s525032334",
"s476537823"
] |
u032223540
|
p02534
|
python
|
s785025507
|
s489835101
| 29
| 25
| 9,008
| 8,992
|
Accepted
|
Accepted
| 13.79
|
K = int(input())
for _ in range(K):
print("ACL", end="")
|
for _ in range(int(input())):
print("ACL", end="")
| 3
| 2
| 60
| 53
|
K = int(input())
for _ in range(K):
print("ACL", end="")
|
for _ in range(int(input())):
print("ACL", end="")
| false
| 33.333333
|
[
"-K = int(input())",
"-for _ in range(K):",
"+for _ in range(int(input())):"
] | false
| 0.042906
| 0.143152
| 0.299725
|
[
"s785025507",
"s489835101"
] |
u186838327
|
p03282
|
python
|
s255043961
|
s566609276
| 177
| 74
| 38,384
| 61,944
|
Accepted
|
Accepted
| 58.19
|
s = str(eval(input()))
k = int(eval(input()))
t = 0
for i in range(len(s)):
temp = s[i]
if temp == '1':
t += 1
else:
break
if t == 0:
print((s[0]))
else:
if k <= t:
print('1')
else:
print(temp)
|
s = str(eval(input()))
k = int(eval(input()))
cnt = 0
for i in range(len(s)):
if s[i] == '1':
cnt += 1
else:
c = s[i]
break
if cnt:
if cnt >= k:
print('1')
else:
print(c)
else:
print(c)
| 21
| 18
| 239
| 253
|
s = str(eval(input()))
k = int(eval(input()))
t = 0
for i in range(len(s)):
temp = s[i]
if temp == "1":
t += 1
else:
break
if t == 0:
print((s[0]))
else:
if k <= t:
print("1")
else:
print(temp)
|
s = str(eval(input()))
k = int(eval(input()))
cnt = 0
for i in range(len(s)):
if s[i] == "1":
cnt += 1
else:
c = s[i]
break
if cnt:
if cnt >= k:
print("1")
else:
print(c)
else:
print(c)
| false
| 14.285714
|
[
"-t = 0",
"+cnt = 0",
"- temp = s[i]",
"- if temp == \"1\":",
"- t += 1",
"+ if s[i] == \"1\":",
"+ cnt += 1",
"+ c = s[i]",
"-if t == 0:",
"- print((s[0]))",
"-else:",
"- if k <= t:",
"+if cnt:",
"+ if cnt >= k:",
"- print(temp)",
"+ print(c)",
"+else:",
"+ print(c)"
] | false
| 0.035367
| 0.036605
| 0.966185
|
[
"s255043961",
"s566609276"
] |
u287132915
|
p02883
|
python
|
s148573825
|
s850114657
| 729
| 672
| 120,396
| 126,156
|
Accepted
|
Accepted
| 7.82
|
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
f = list(map(int, input().split()))
a.sort()
f.sort()
a = a[::-1]
kaketa = []
for i in range(n):
kaketa.append(a[i]*f[i])
left = 0
right = max(kaketa)
while True:
jiku = (left+right)//2
kaisuu = 0
for i in range(n):
if kaketa[i] - jiku > 0:
if (kaketa[i] - jiku) % f[i] != 0:
kaisuu += (kaketa[i] - jiku) // f[i] + 1
else:
kaisuu += (kaketa[i] - jiku) // f[i]
if kaisuu > k:
left = jiku
else:
right = jiku
if right - left == 1:
break
if sum(a) <= k:
print((0))
else:
print(right)
|
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
f = list(map(int, input().split()))
a.sort()
f.sort(reverse=True)
lst = []
maxi = 0
for i in range(n):
lst.append([a[i]*f[i], f[i]])
maxi = max(maxi, a[i]*f[i])
left = -1 # 不可能
right = maxi # 可能
while left+1 < right:
mid = (left+right)//2
cnt = 0
for i in range(n):
lsti = lst[i]
if lsti[0] > mid:
sa = lsti[0] - mid
cnt += (sa+lsti[1]-1) // lsti[1]
if cnt <= k:
right = mid
else:
left = mid
print(right)
| 34
| 27
| 707
| 585
|
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
f = list(map(int, input().split()))
a.sort()
f.sort()
a = a[::-1]
kaketa = []
for i in range(n):
kaketa.append(a[i] * f[i])
left = 0
right = max(kaketa)
while True:
jiku = (left + right) // 2
kaisuu = 0
for i in range(n):
if kaketa[i] - jiku > 0:
if (kaketa[i] - jiku) % f[i] != 0:
kaisuu += (kaketa[i] - jiku) // f[i] + 1
else:
kaisuu += (kaketa[i] - jiku) // f[i]
if kaisuu > k:
left = jiku
else:
right = jiku
if right - left == 1:
break
if sum(a) <= k:
print((0))
else:
print(right)
|
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
f = list(map(int, input().split()))
a.sort()
f.sort(reverse=True)
lst = []
maxi = 0
for i in range(n):
lst.append([a[i] * f[i], f[i]])
maxi = max(maxi, a[i] * f[i])
left = -1 # 不可能
right = maxi # 可能
while left + 1 < right:
mid = (left + right) // 2
cnt = 0
for i in range(n):
lsti = lst[i]
if lsti[0] > mid:
sa = lsti[0] - mid
cnt += (sa + lsti[1] - 1) // lsti[1]
if cnt <= k:
right = mid
else:
left = mid
print(right)
| false
| 20.588235
|
[
"-f.sort()",
"-a = a[::-1]",
"-kaketa = []",
"+f.sort(reverse=True)",
"+lst = []",
"+maxi = 0",
"- kaketa.append(a[i] * f[i])",
"-left = 0",
"-right = max(kaketa)",
"-while True:",
"- jiku = (left + right) // 2",
"- kaisuu = 0",
"+ lst.append([a[i] * f[i], f[i]])",
"+ maxi = max(maxi, a[i] * f[i])",
"+left = -1 # 不可能",
"+right = maxi # 可能",
"+while left + 1 < right:",
"+ mid = (left + right) // 2",
"+ cnt = 0",
"- if kaketa[i] - jiku > 0:",
"- if (kaketa[i] - jiku) % f[i] != 0:",
"- kaisuu += (kaketa[i] - jiku) // f[i] + 1",
"- else:",
"- kaisuu += (kaketa[i] - jiku) // f[i]",
"- if kaisuu > k:",
"- left = jiku",
"+ lsti = lst[i]",
"+ if lsti[0] > mid:",
"+ sa = lsti[0] - mid",
"+ cnt += (sa + lsti[1] - 1) // lsti[1]",
"+ if cnt <= k:",
"+ right = mid",
"- right = jiku",
"- if right - left == 1:",
"- break",
"-if sum(a) <= k:",
"- print((0))",
"-else:",
"- print(right)",
"+ left = mid",
"+print(right)"
] | false
| 0.072158
| 0.118929
| 0.606734
|
[
"s148573825",
"s850114657"
] |
u583507988
|
p03127
|
python
|
s573602868
|
s010952486
| 78
| 68
| 20,260
| 20,340
|
Accepted
|
Accepted
| 12.82
|
from math import gcd
n = int(eval(input()))
a = list(map(int, input().split()))
for i in range(n-1):
a[i+1] = gcd(a[i], a[i+1])
print((a[n-1]))
|
from math import gcd
n=int(eval(input()))
a=list(map(int,input().split()))
res=a[0]
for i in range(1,n):
res=gcd(res,a[i])
print(res)
| 10
| 7
| 152
| 135
|
from math import gcd
n = int(eval(input()))
a = list(map(int, input().split()))
for i in range(n - 1):
a[i + 1] = gcd(a[i], a[i + 1])
print((a[n - 1]))
|
from math import gcd
n = int(eval(input()))
a = list(map(int, input().split()))
res = a[0]
for i in range(1, n):
res = gcd(res, a[i])
print(res)
| false
| 30
|
[
"-for i in range(n - 1):",
"- a[i + 1] = gcd(a[i], a[i + 1])",
"-print((a[n - 1]))",
"+res = a[0]",
"+for i in range(1, n):",
"+ res = gcd(res, a[i])",
"+print(res)"
] | false
| 0.044183
| 0.068821
| 0.641995
|
[
"s573602868",
"s010952486"
] |
u695811449
|
p03862
|
python
|
s826246240
|
s839057415
| 241
| 139
| 14,548
| 14,472
|
Accepted
|
Accepted
| 42.32
|
N,x=list(map(int,input().split()))
A=list(map(int,input().split()))
A2=A[::-1]
ANS=0
for i in range(1,N):
if A[i]+A[i-1]>x:
ANS+=(A[i]+A[i-1]-x)
if A[i]>=A[i]+A[i-1]-x:
A[i]-=(A[i]+A[i-1]-x)
else:
A[i]=0
ANS2=0
for i in range(1,N):
if A2[i]+A2[i-1]>x:
ANS2+=(A2[i]+A2[i-1]-x)
if A2[i]>=A2[i]+A2[i-1]-x:
A2[i]-=(A2[i]+A2[i-1]-x)
else:
A2[i]=0
print((min(ANS,ANS2)))
|
N,x=list(map(int,input().split()))
A=list(map(int,input().split()))
ANS=0
for i in range(1,N):
if A[i]+A[i-1]>x:
ANS+=(A[i]+A[i-1]-x)
if A[i]>=A[i]+A[i-1]-x:
A[i]-=(A[i]+A[i-1]-x)
else:
A[i]=0
print(ANS)
| 25
| 13
| 489
| 264
|
N, x = list(map(int, input().split()))
A = list(map(int, input().split()))
A2 = A[::-1]
ANS = 0
for i in range(1, N):
if A[i] + A[i - 1] > x:
ANS += A[i] + A[i - 1] - x
if A[i] >= A[i] + A[i - 1] - x:
A[i] -= A[i] + A[i - 1] - x
else:
A[i] = 0
ANS2 = 0
for i in range(1, N):
if A2[i] + A2[i - 1] > x:
ANS2 += A2[i] + A2[i - 1] - x
if A2[i] >= A2[i] + A2[i - 1] - x:
A2[i] -= A2[i] + A2[i - 1] - x
else:
A2[i] = 0
print((min(ANS, ANS2)))
|
N, x = list(map(int, input().split()))
A = list(map(int, input().split()))
ANS = 0
for i in range(1, N):
if A[i] + A[i - 1] > x:
ANS += A[i] + A[i - 1] - x
if A[i] >= A[i] + A[i - 1] - x:
A[i] -= A[i] + A[i - 1] - x
else:
A[i] = 0
print(ANS)
| false
| 48
|
[
"-A2 = A[::-1]",
"-ANS2 = 0",
"-for i in range(1, N):",
"- if A2[i] + A2[i - 1] > x:",
"- ANS2 += A2[i] + A2[i - 1] - x",
"- if A2[i] >= A2[i] + A2[i - 1] - x:",
"- A2[i] -= A2[i] + A2[i - 1] - x",
"- else:",
"- A2[i] = 0",
"-print((min(ANS, ANS2)))",
"+print(ANS)"
] | false
| 0.056429
| 0.051006
| 1.106318
|
[
"s826246240",
"s839057415"
] |
u738898077
|
p03634
|
python
|
s686285543
|
s144783413
| 1,689
| 845
| 101,988
| 48,964
|
Accepted
|
Accepted
| 49.97
|
n = int(eval(input()))
v = [[0]+[]*(n+1) for i in range(n+1)]
for i in range(n-1):
a,b,c = list(map(int,input().split()))
v[a].append([b,c])
v[b].append([a,c])
q,k = list(map(int,input().split()))
l = [k]
while l:
now = l.pop()
for i in v[now][1:]:
if v[i[0]][0] == 0:
v[i[0]][0] = i[1]+v[now][0]
l.append(i[0])
for i in range(q):
x,y = list(map(int,input().split()))
print((v[x][0]+v[y][0]))
|
import sys
input = sys.stdin.readline
n = int(eval(input()))
v = [[0]+[]*(n+1) for i in range(n+1)]
for i in range(n-1):
a,b,c = list(map(int,input().split()))
v[a].append([b,c])
v[b].append([a,c])
q,k = list(map(int,input().split()))
l = [k]
while l:
now = l.pop()
for i in v[now][1:]:
if v[i[0]][0] == 0:
v[i[0]][0] = i[1]+v[now][0]
l.append(i[0])
for i in range(q):
x,y = list(map(int,input().split()))
print((v[x][0]+v[y][0]))
| 19
| 21
| 458
| 486
|
n = int(eval(input()))
v = [[0] + [] * (n + 1) for i in range(n + 1)]
for i in range(n - 1):
a, b, c = list(map(int, input().split()))
v[a].append([b, c])
v[b].append([a, c])
q, k = list(map(int, input().split()))
l = [k]
while l:
now = l.pop()
for i in v[now][1:]:
if v[i[0]][0] == 0:
v[i[0]][0] = i[1] + v[now][0]
l.append(i[0])
for i in range(q):
x, y = list(map(int, input().split()))
print((v[x][0] + v[y][0]))
|
import sys
input = sys.stdin.readline
n = int(eval(input()))
v = [[0] + [] * (n + 1) for i in range(n + 1)]
for i in range(n - 1):
a, b, c = list(map(int, input().split()))
v[a].append([b, c])
v[b].append([a, c])
q, k = list(map(int, input().split()))
l = [k]
while l:
now = l.pop()
for i in v[now][1:]:
if v[i[0]][0] == 0:
v[i[0]][0] = i[1] + v[now][0]
l.append(i[0])
for i in range(q):
x, y = list(map(int, input().split()))
print((v[x][0] + v[y][0]))
| false
| 9.52381
|
[
"+import sys",
"+",
"+input = sys.stdin.readline"
] | false
| 0.039445
| 0.040629
| 0.970861
|
[
"s686285543",
"s144783413"
] |
u078349616
|
p02819
|
python
|
s721897015
|
s306148279
| 214
| 26
| 2,940
| 2,940
|
Accepted
|
Accepted
| 87.85
|
# ABC149 C - Next Prime
X = int(eval(input()))
def isPrime(n):
cnt = 0
for i in range(1, n + 1):
if n % i == 0:
cnt += 1
if cnt == 2:
return True
else:
return False
while True:
if isPrime(X):
print(X)
break
else:
X += 1
|
# ABC149 C - Next Prime
X = int(eval(input()))
def isPrime(n):
for i in range(2, n):
if n % i == 0:
return False
return True
while True:
if isPrime(X):
print(X)
break
else:
X += 1
| 19
| 15
| 317
| 249
|
# ABC149 C - Next Prime
X = int(eval(input()))
def isPrime(n):
cnt = 0
for i in range(1, n + 1):
if n % i == 0:
cnt += 1
if cnt == 2:
return True
else:
return False
while True:
if isPrime(X):
print(X)
break
else:
X += 1
|
# ABC149 C - Next Prime
X = int(eval(input()))
def isPrime(n):
for i in range(2, n):
if n % i == 0:
return False
return True
while True:
if isPrime(X):
print(X)
break
else:
X += 1
| false
| 21.052632
|
[
"- cnt = 0",
"- for i in range(1, n + 1):",
"+ for i in range(2, n):",
"- cnt += 1",
"- if cnt == 2:",
"- return True",
"- else:",
"- return False",
"+ return False",
"+ return True"
] | false
| 0.04759
| 0.038056
| 1.250532
|
[
"s721897015",
"s306148279"
] |
u588341295
|
p02925
|
python
|
s975794960
|
s264580396
| 1,237
| 1,047
| 36,080
| 36,080
|
Accepted
|
Accepted
| 15.36
|
# -*- coding: utf-8 -*-
import sys
import time
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 ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7
N = INT()
A = [deque()]
for i in range(N):
A.append(deque(LIST()))
start = time.time()
cnt = N*(N-1)//2
day = 0
while cnt > 0:
prev = cnt
skip = [False] * (N+1)
for i in range(1, N+1):
if len(A[i]) and not skip[i]:
a = A[i][0]
if len(A[a]) and not skip[a]:
b = A[a][0]
if i == b:
A[i].popleft()
A[a].popleft()
cnt -= 1
skip[i] = skip[a] = True
if prev == cnt:
print((-1))
exit()
day += 1
elapsed_time = time.time() - start
if elapsed_time > 1:
print((N*(N-1)//2))
exit()
print(day)
|
# -*- coding: utf-8 -*-
import sys
import time
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 ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7
start = time.time()
N = INT()
A = [deque()]
for i in range(N):
A.append(deque(LIST()))
cnt = N*(N-1)//2
day = 0
while cnt > 0:
prev = cnt
skip = [False] * (N+1)
for i in range(1, N+1):
if len(A[i]) and not skip[i]:
a = A[i][0]
if len(A[a]) and not skip[a]:
b = A[a][0]
if i == b:
A[i].popleft()
A[a].popleft()
cnt -= 1
skip[i] = skip[a] = True
if prev == cnt:
print((-1))
exit()
day += 1
elapsed_time = time.time() - start
if elapsed_time > 1:
print((N*(N-1)//2))
exit()
print(day)
| 53
| 53
| 1,332
| 1,332
|
# -*- coding: utf-8 -*-
import sys
import time
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 ceil(x, y=1):
return int(-(-x // y))
def INT():
return int(eval(input()))
def MAP():
return list(map(int, input().split()))
def LIST():
return list(map(int, input().split()))
def Yes():
print("Yes")
def No():
print("No")
def YES():
print("YES")
def NO():
print("NO")
sys.setrecursionlimit(10**9)
INF = float("inf")
MOD = 10**9 + 7
N = INT()
A = [deque()]
for i in range(N):
A.append(deque(LIST()))
start = time.time()
cnt = N * (N - 1) // 2
day = 0
while cnt > 0:
prev = cnt
skip = [False] * (N + 1)
for i in range(1, N + 1):
if len(A[i]) and not skip[i]:
a = A[i][0]
if len(A[a]) and not skip[a]:
b = A[a][0]
if i == b:
A[i].popleft()
A[a].popleft()
cnt -= 1
skip[i] = skip[a] = True
if prev == cnt:
print((-1))
exit()
day += 1
elapsed_time = time.time() - start
if elapsed_time > 1:
print((N * (N - 1) // 2))
exit()
print(day)
|
# -*- coding: utf-8 -*-
import sys
import time
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 ceil(x, y=1):
return int(-(-x // y))
def INT():
return int(eval(input()))
def MAP():
return list(map(int, input().split()))
def LIST():
return list(map(int, input().split()))
def Yes():
print("Yes")
def No():
print("No")
def YES():
print("YES")
def NO():
print("NO")
sys.setrecursionlimit(10**9)
INF = float("inf")
MOD = 10**9 + 7
start = time.time()
N = INT()
A = [deque()]
for i in range(N):
A.append(deque(LIST()))
cnt = N * (N - 1) // 2
day = 0
while cnt > 0:
prev = cnt
skip = [False] * (N + 1)
for i in range(1, N + 1):
if len(A[i]) and not skip[i]:
a = A[i][0]
if len(A[a]) and not skip[a]:
b = A[a][0]
if i == b:
A[i].popleft()
A[a].popleft()
cnt -= 1
skip[i] = skip[a] = True
if prev == cnt:
print((-1))
exit()
day += 1
elapsed_time = time.time() - start
if elapsed_time > 1:
print((N * (N - 1) // 2))
exit()
print(day)
| false
| 0
|
[
"+start = time.time()",
"-start = time.time()"
] | false
| 0.055324
| 0.036739
| 1.505863
|
[
"s975794960",
"s264580396"
] |
u761320129
|
p03599
|
python
|
s188506629
|
s853311866
| 79
| 56
| 3,188
| 3,188
|
Accepted
|
Accepted
| 29.11
|
A,B,C,D,E,F = list(map(int,input().split()))
waters = set()
for w1 in range(0,F+1,B):
if w1*100 > F: break
for w2 in range(0,F+1,A):
w = (w1+w2)*100
if w > F: break
if w==0: continue
waters.add(w)
sugars = set()
for s1 in range(0,F+1,D):
if s1 > F: break
for s2 in range(0,F+1,C):
s = s1+s2
if s > F: break
sugars.add(s)
ans_r = -1
ans_s = ans_w = None
for w in sorted(waters):
if w > F: break
for s in sorted(sugars):
if w+s > F: break
if s*100 > w*E: break
r = 100*s/(s+w)
if r > ans_r:
ans_r = r
ans_w = w
ans_s = s
print((ans_s+ans_w, ans_s))
|
A,B,C,D,E,F = list(map(int,input().split()))
waters = set()
for b in range(0, F+1, 100*B):
for a in range(0, F-b+1, 100*A):
waters.add(a+b)
waters.remove(0)
sugars = set()
for d in range(0, F+1, D):
for c in range(0, F-d+1, C):
sugars.add(c+d)
best_w = best_s = best_r = -1
for water in sorted(waters):
for sugar in sorted(sugars):
if water + sugar > F: break
if water*E < sugar*100: break
rate = sugar / (water + sugar)
if rate > best_r:
best_r = rate
best_w = water
best_s = sugar
print((best_s+best_w, best_s))
| 32
| 24
| 721
| 627
|
A, B, C, D, E, F = list(map(int, input().split()))
waters = set()
for w1 in range(0, F + 1, B):
if w1 * 100 > F:
break
for w2 in range(0, F + 1, A):
w = (w1 + w2) * 100
if w > F:
break
if w == 0:
continue
waters.add(w)
sugars = set()
for s1 in range(0, F + 1, D):
if s1 > F:
break
for s2 in range(0, F + 1, C):
s = s1 + s2
if s > F:
break
sugars.add(s)
ans_r = -1
ans_s = ans_w = None
for w in sorted(waters):
if w > F:
break
for s in sorted(sugars):
if w + s > F:
break
if s * 100 > w * E:
break
r = 100 * s / (s + w)
if r > ans_r:
ans_r = r
ans_w = w
ans_s = s
print((ans_s + ans_w, ans_s))
|
A, B, C, D, E, F = list(map(int, input().split()))
waters = set()
for b in range(0, F + 1, 100 * B):
for a in range(0, F - b + 1, 100 * A):
waters.add(a + b)
waters.remove(0)
sugars = set()
for d in range(0, F + 1, D):
for c in range(0, F - d + 1, C):
sugars.add(c + d)
best_w = best_s = best_r = -1
for water in sorted(waters):
for sugar in sorted(sugars):
if water + sugar > F:
break
if water * E < sugar * 100:
break
rate = sugar / (water + sugar)
if rate > best_r:
best_r = rate
best_w = water
best_s = sugar
print((best_s + best_w, best_s))
| false
| 25
|
[
"-for w1 in range(0, F + 1, B):",
"- if w1 * 100 > F:",
"- break",
"- for w2 in range(0, F + 1, A):",
"- w = (w1 + w2) * 100",
"- if w > F:",
"+for b in range(0, F + 1, 100 * B):",
"+ for a in range(0, F - b + 1, 100 * A):",
"+ waters.add(a + b)",
"+waters.remove(0)",
"+sugars = set()",
"+for d in range(0, F + 1, D):",
"+ for c in range(0, F - d + 1, C):",
"+ sugars.add(c + d)",
"+best_w = best_s = best_r = -1",
"+for water in sorted(waters):",
"+ for sugar in sorted(sugars):",
"+ if water + sugar > F:",
"- if w == 0:",
"- continue",
"- waters.add(w)",
"-sugars = set()",
"-for s1 in range(0, F + 1, D):",
"- if s1 > F:",
"- break",
"- for s2 in range(0, F + 1, C):",
"- s = s1 + s2",
"- if s > F:",
"+ if water * E < sugar * 100:",
"- sugars.add(s)",
"-ans_r = -1",
"-ans_s = ans_w = None",
"-for w in sorted(waters):",
"- if w > F:",
"- break",
"- for s in sorted(sugars):",
"- if w + s > F:",
"- break",
"- if s * 100 > w * E:",
"- break",
"- r = 100 * s / (s + w)",
"- if r > ans_r:",
"- ans_r = r",
"- ans_w = w",
"- ans_s = s",
"-print((ans_s + ans_w, ans_s))",
"+ rate = sugar / (water + sugar)",
"+ if rate > best_r:",
"+ best_r = rate",
"+ best_w = water",
"+ best_s = sugar",
"+print((best_s + best_w, best_s))"
] | false
| 0.158086
| 0.074749
| 2.114909
|
[
"s188506629",
"s853311866"
] |
u006657459
|
p04046
|
python
|
s746656996
|
s423917404
| 1,504
| 1,005
| 10,868
| 19,808
|
Accepted
|
Accepted
| 33.18
|
from math import factorial
mod = 10**9 + 7
H, W, A, B = list(map(int, input().split()))
memo_fact = [1] * (H + W - 1)
memo_denometer = {}
for i in range(1, H + W - 1):
memo_fact[i] = memo_fact[i - 1] * i % mod
def nCr(n,r):
numerator = memo_fact[n]
if (n, r) in memo_denometer:
denometer = memo_denometer[(n, r)]
else:
denometer = pow(memo_fact[r], mod-2, mod) * pow(memo_fact[n-r], mod-2, mod)
return (numerator * denometer) % mod
result = 0
for i in range(1, H - A + 1):
result += (nCr((B-1)+(i-1), i-1) * nCr((W-B-1)+(H-i), W-B-1)) % mod
print((int(result % mod)))
|
H, W, A, B = list(map(int, input().split()))
mod = 10**9 + 7
fact = [1] * (H + W - 1)
invfact = [1] * (H + W - 1)
for i in range(1, H + W - 1):
fact[i] = fact[i - 1] * i % mod
for i in range(1, H + W - 1):
invfact[i] = pow(fact[i], mod-2, mod)
def nCr(n,r):
return fact[n] * invfact[r] * invfact[n-r]
result = 0
for i in range(1, H - A + 1):
result += (nCr((B-1)+(i-1), i-1) * nCr((W-B-1)+(H-i), W-B-1)) % mod
print((int(result % mod)))
| 22
| 19
| 624
| 467
|
from math import factorial
mod = 10**9 + 7
H, W, A, B = list(map(int, input().split()))
memo_fact = [1] * (H + W - 1)
memo_denometer = {}
for i in range(1, H + W - 1):
memo_fact[i] = memo_fact[i - 1] * i % mod
def nCr(n, r):
numerator = memo_fact[n]
if (n, r) in memo_denometer:
denometer = memo_denometer[(n, r)]
else:
denometer = pow(memo_fact[r], mod - 2, mod) * pow(
memo_fact[n - r], mod - 2, mod
)
return (numerator * denometer) % mod
result = 0
for i in range(1, H - A + 1):
result += (
nCr((B - 1) + (i - 1), i - 1) * nCr((W - B - 1) + (H - i), W - B - 1)
) % mod
print((int(result % mod)))
|
H, W, A, B = list(map(int, input().split()))
mod = 10**9 + 7
fact = [1] * (H + W - 1)
invfact = [1] * (H + W - 1)
for i in range(1, H + W - 1):
fact[i] = fact[i - 1] * i % mod
for i in range(1, H + W - 1):
invfact[i] = pow(fact[i], mod - 2, mod)
def nCr(n, r):
return fact[n] * invfact[r] * invfact[n - r]
result = 0
for i in range(1, H - A + 1):
result += (
nCr((B - 1) + (i - 1), i - 1) * nCr((W - B - 1) + (H - i), W - B - 1)
) % mod
print((int(result % mod)))
| false
| 13.636364
|
[
"-from math import factorial",
"-",
"+H, W, A, B = list(map(int, input().split()))",
"-H, W, A, B = list(map(int, input().split()))",
"-memo_fact = [1] * (H + W - 1)",
"-memo_denometer = {}",
"+fact = [1] * (H + W - 1)",
"+invfact = [1] * (H + W - 1)",
"- memo_fact[i] = memo_fact[i - 1] * i % mod",
"+ fact[i] = fact[i - 1] * i % mod",
"+for i in range(1, H + W - 1):",
"+ invfact[i] = pow(fact[i], mod - 2, mod)",
"- numerator = memo_fact[n]",
"- if (n, r) in memo_denometer:",
"- denometer = memo_denometer[(n, r)]",
"- else:",
"- denometer = pow(memo_fact[r], mod - 2, mod) * pow(",
"- memo_fact[n - r], mod - 2, mod",
"- )",
"- return (numerator * denometer) % mod",
"+ return fact[n] * invfact[r] * invfact[n - r]"
] | false
| 0.046274
| 0.047022
| 0.984095
|
[
"s746656996",
"s423917404"
] |
u912237403
|
p00175
|
python
|
s826258291
|
s315041568
| 30
| 20
| 4,196
| 4,196
|
Accepted
|
Accepted
| 33.33
|
while 1:
a = eval(input())
if a<0: break
x=[]
while a:
x.append(str(a % 4))
a/=4
if x==[]: x="0"
print("".join(x[::-1]))
|
while 1:
a = eval(input())
if a<0: break
x=''
while a:
x = str(a % 4)+x
a/=4
print([x,'0'][x==''])
| 9
| 8
| 141
| 116
|
while 1:
a = eval(input())
if a < 0:
break
x = []
while a:
x.append(str(a % 4))
a /= 4
if x == []:
x = "0"
print("".join(x[::-1]))
|
while 1:
a = eval(input())
if a < 0:
break
x = ""
while a:
x = str(a % 4) + x
a /= 4
print([x, "0"][x == ""])
| false
| 11.111111
|
[
"- x = []",
"+ x = \"\"",
"- x.append(str(a % 4))",
"+ x = str(a % 4) + x",
"- if x == []:",
"- x = \"0\"",
"- print(\"\".join(x[::-1]))",
"+ print([x, \"0\"][x == \"\"])"
] | false
| 0.060901
| 0.063134
| 0.964625
|
[
"s826258291",
"s315041568"
] |
u620480037
|
p03565
|
python
|
s322183232
|
s780667447
| 24
| 17
| 3,064
| 3,064
|
Accepted
|
Accepted
| 29.17
|
S=eval(input())
T=eval(input())
for i in range(len(S)-len(T)+1):
cnt=0
for j in range(len(T)):
if S[len(S)-len(T)-i+j]=="?":
cnt+=1
else:
if S[len(S)-len(T)-i+j]==T[j]:
cnt+=1
if len(T)==cnt:
ANS=S[:len(S)-len(T)-i]+T+S[len(S)-i:]
ANS=ANS.replace("?","a")
print(ANS)
exit()
print("UNRESTORABLE")
|
s=list(eval(input()))
T=list(eval(input()))
for i in range(len(s)-len(T)+1):
F=0
for j in range(len(T)):
if s[len(s)-1-i-j]==T[len(T)-j-1] or s[len(s)-1-i-j]=="?":
continue
else:
F=1
break
if F==0:
for j in range(len(T)):
if s[len(s)-1-i-j]=="?":
s[len(s)-1-i-j]=T[len(T)-j-1]
for j in range(len(s)):
if s[j]=="?":
s[j]="a"
print(("".join(s)))
exit()
print("UNRESTORABLE")
| 19
| 22
| 408
| 542
|
S = eval(input())
T = eval(input())
for i in range(len(S) - len(T) + 1):
cnt = 0
for j in range(len(T)):
if S[len(S) - len(T) - i + j] == "?":
cnt += 1
else:
if S[len(S) - len(T) - i + j] == T[j]:
cnt += 1
if len(T) == cnt:
ANS = S[: len(S) - len(T) - i] + T + S[len(S) - i :]
ANS = ANS.replace("?", "a")
print(ANS)
exit()
print("UNRESTORABLE")
|
s = list(eval(input()))
T = list(eval(input()))
for i in range(len(s) - len(T) + 1):
F = 0
for j in range(len(T)):
if s[len(s) - 1 - i - j] == T[len(T) - j - 1] or s[len(s) - 1 - i - j] == "?":
continue
else:
F = 1
break
if F == 0:
for j in range(len(T)):
if s[len(s) - 1 - i - j] == "?":
s[len(s) - 1 - i - j] = T[len(T) - j - 1]
for j in range(len(s)):
if s[j] == "?":
s[j] = "a"
print(("".join(s)))
exit()
print("UNRESTORABLE")
| false
| 13.636364
|
[
"-S = eval(input())",
"-T = eval(input())",
"-for i in range(len(S) - len(T) + 1):",
"- cnt = 0",
"+s = list(eval(input()))",
"+T = list(eval(input()))",
"+for i in range(len(s) - len(T) + 1):",
"+ F = 0",
"- if S[len(S) - len(T) - i + j] == \"?\":",
"- cnt += 1",
"+ if s[len(s) - 1 - i - j] == T[len(T) - j - 1] or s[len(s) - 1 - i - j] == \"?\":",
"+ continue",
"- if S[len(S) - len(T) - i + j] == T[j]:",
"- cnt += 1",
"- if len(T) == cnt:",
"- ANS = S[: len(S) - len(T) - i] + T + S[len(S) - i :]",
"- ANS = ANS.replace(\"?\", \"a\")",
"- print(ANS)",
"+ F = 1",
"+ break",
"+ if F == 0:",
"+ for j in range(len(T)):",
"+ if s[len(s) - 1 - i - j] == \"?\":",
"+ s[len(s) - 1 - i - j] = T[len(T) - j - 1]",
"+ for j in range(len(s)):",
"+ if s[j] == \"?\":",
"+ s[j] = \"a\"",
"+ print((\"\".join(s)))"
] | false
| 0.113623
| 0.044258
| 2.567276
|
[
"s322183232",
"s780667447"
] |
u169350228
|
p02687
|
python
|
s521414496
|
s438715884
| 108
| 19
| 27,132
| 8,908
|
Accepted
|
Accepted
| 82.41
|
import numpy as np
import math
s = eval(input())
if s == "ABC":
print("ARC")
else:
print("ABC")
|
s = eval(input())
if s == "ABC":
print("ARC")
else:
print("ABC")
| 7
| 6
| 103
| 72
|
import numpy as np
import math
s = eval(input())
if s == "ABC":
print("ARC")
else:
print("ABC")
|
s = eval(input())
if s == "ABC":
print("ARC")
else:
print("ABC")
| false
| 14.285714
|
[
"-import numpy as np",
"-import math",
"-"
] | false
| 0.077971
| 0.038409
| 2.030028
|
[
"s521414496",
"s438715884"
] |
u506910932
|
p03472
|
python
|
s489827621
|
s006298577
| 383
| 252
| 7,512
| 7,512
|
Accepted
|
Accepted
| 34.2
|
import math
n, h = list(map(int, input().split()))
sl = 0
th = []
for i in range(n):
a, b = list(map(int, input().split()))
sl = max(sl, a)
th.append(b)
th.sort()
th_damage = th.pop()
turn = 0
while (h > 0):
if th_damage > sl:
h -= th_damage
if len(th) != 0:
th_damage = th.pop()
else:
th_damage = 0
else:
turn += math.ceil(h / sl)
break
turn += 1
print(turn)
|
# 16:15
import sys
input = lambda: sys.stdin.readline().rstrip()
import math
n, h = list(map(int, input().split()))
sl = 0
th = []
for i in range(n):
a, b = list(map(int, input().split()))
sl = max(sl, a)
th.append(b)
th.sort()
th_damage = th.pop()
turn = 0
while (h > 0):
if th_damage > sl:
h -= th_damage
if len(th) != 0:
th_damage = th.pop()
else:
th_damage = 0
else:
turn += math.ceil(h / sl)
break
turn += 1
print(turn)
| 25
| 28
| 462
| 530
|
import math
n, h = list(map(int, input().split()))
sl = 0
th = []
for i in range(n):
a, b = list(map(int, input().split()))
sl = max(sl, a)
th.append(b)
th.sort()
th_damage = th.pop()
turn = 0
while h > 0:
if th_damage > sl:
h -= th_damage
if len(th) != 0:
th_damage = th.pop()
else:
th_damage = 0
else:
turn += math.ceil(h / sl)
break
turn += 1
print(turn)
|
# 16:15
import sys
input = lambda: sys.stdin.readline().rstrip()
import math
n, h = list(map(int, input().split()))
sl = 0
th = []
for i in range(n):
a, b = list(map(int, input().split()))
sl = max(sl, a)
th.append(b)
th.sort()
th_damage = th.pop()
turn = 0
while h > 0:
if th_damage > sl:
h -= th_damage
if len(th) != 0:
th_damage = th.pop()
else:
th_damage = 0
else:
turn += math.ceil(h / sl)
break
turn += 1
print(turn)
| false
| 10.714286
|
[
"+# 16:15",
"+import sys",
"+",
"+input = lambda: sys.stdin.readline().rstrip()"
] | false
| 0.047697
| 0.047531
| 1.003501
|
[
"s489827621",
"s006298577"
] |
u576432509
|
p03633
|
python
|
s001562728
|
s937907921
| 39
| 35
| 5,340
| 5,048
|
Accepted
|
Accepted
| 10.26
|
# ==================== gcd 最大公約数
from fractions import gcd
# ==================== gcd 最小公倍数
def lcm(a, b):
return a//gcd(a, b) * b
n=int(eval(input()))
t=[]
for i in range(n):
t.append(int(eval(input())))
if n==1:
print((t[0]))
else:
tlcm=t[0]
for i in range(1,n):
tlcm=lcm(tlcm,t[i])
print(tlcm)
|
from fractions import gcd
#from math import gcd
n=int(eval(input()))
lcm=int(eval(input()))
for i in range(n-1):
ti=int(eval(input()))
lcm= lcm//gcd(lcm, ti) * ti
print(lcm)
| 21
| 9
| 361
| 172
|
# ==================== gcd 最大公約数
from fractions import gcd
# ==================== gcd 最小公倍数
def lcm(a, b):
return a // gcd(a, b) * b
n = int(eval(input()))
t = []
for i in range(n):
t.append(int(eval(input())))
if n == 1:
print((t[0]))
else:
tlcm = t[0]
for i in range(1, n):
tlcm = lcm(tlcm, t[i])
print(tlcm)
|
from fractions import gcd
# from math import gcd
n = int(eval(input()))
lcm = int(eval(input()))
for i in range(n - 1):
ti = int(eval(input()))
lcm = lcm // gcd(lcm, ti) * ti
print(lcm)
| false
| 57.142857
|
[
"-# ==================== gcd 最大公約数",
"-# ==================== gcd 最小公倍数",
"-def lcm(a, b):",
"- return a // gcd(a, b) * b",
"-",
"-",
"+# from math import gcd",
"-t = []",
"-for i in range(n):",
"- t.append(int(eval(input())))",
"-if n == 1:",
"- print((t[0]))",
"-else:",
"- tlcm = t[0]",
"- for i in range(1, n):",
"- tlcm = lcm(tlcm, t[i])",
"- print(tlcm)",
"+lcm = int(eval(input()))",
"+for i in range(n - 1):",
"+ ti = int(eval(input()))",
"+ lcm = lcm // gcd(lcm, ti) * ti",
"+print(lcm)"
] | false
| 0.100537
| 0.098337
| 1.022371
|
[
"s001562728",
"s937907921"
] |
u562935282
|
p03457
|
python
|
s773830075
|
s996543613
| 421
| 333
| 11,828
| 3,060
|
Accepted
|
Accepted
| 20.9
|
def BlCannotGo(dt, dx, dy): ## 行けないならTrue
dist = dx + dy
if (dt % 2) != (dist % 2) or dist > dt:
return True
else:
return False
def abs(x):
if x>=0:
return x
else:
return -x
if __name__ == '__main__':
n = int(eval(input()))
t = list(False for _ in range(n+1))
x = list(False for _ in range(n+1))
y = list(False for _ in range(n+1))
t[0], x[0], y[0] = 0, 0, 0
for i in range(n):
t[i+1], x[i+1], y[i+1] = list(map(int, input().split()))
for i in range(1,n+1):
dt = t[i] - t[i-1]
dx = abs(x[i] - x[i-1])
dy = abs(y[i] - y[i-1])
if BlCannotGo(dt, dx, dy):
print('No')
exit()
print('Yes')
|
def main():
n = int(eval(input()))
pt, px, py = 0, 0, 0
for _ in range(n):
t, x, y = list(map(int, input().split()))
dt = t - pt
dx = abs(x - px)
dy = abs(y - py)
if (dx + dy) % 2 != dt % 2:
print('No')
return
if (dx + dy) > dt:
print('No')
return
print('Yes')
if __name__ == '__main__':
main()
| 31
| 20
| 764
| 421
|
def BlCannotGo(dt, dx, dy): ## 行けないならTrue
dist = dx + dy
if (dt % 2) != (dist % 2) or dist > dt:
return True
else:
return False
def abs(x):
if x >= 0:
return x
else:
return -x
if __name__ == "__main__":
n = int(eval(input()))
t = list(False for _ in range(n + 1))
x = list(False for _ in range(n + 1))
y = list(False for _ in range(n + 1))
t[0], x[0], y[0] = 0, 0, 0
for i in range(n):
t[i + 1], x[i + 1], y[i + 1] = list(map(int, input().split()))
for i in range(1, n + 1):
dt = t[i] - t[i - 1]
dx = abs(x[i] - x[i - 1])
dy = abs(y[i] - y[i - 1])
if BlCannotGo(dt, dx, dy):
print("No")
exit()
print("Yes")
|
def main():
n = int(eval(input()))
pt, px, py = 0, 0, 0
for _ in range(n):
t, x, y = list(map(int, input().split()))
dt = t - pt
dx = abs(x - px)
dy = abs(y - py)
if (dx + dy) % 2 != dt % 2:
print("No")
return
if (dx + dy) > dt:
print("No")
return
print("Yes")
if __name__ == "__main__":
main()
| false
| 35.483871
|
[
"-def BlCannotGo(dt, dx, dy): ## 行けないならTrue",
"- dist = dx + dy",
"- if (dt % 2) != (dist % 2) or dist > dt:",
"- return True",
"- else:",
"- return False",
"-",
"-",
"-def abs(x):",
"- if x >= 0:",
"- return x",
"- else:",
"- return -x",
"+def main():",
"+ n = int(eval(input()))",
"+ pt, px, py = 0, 0, 0",
"+ for _ in range(n):",
"+ t, x, y = list(map(int, input().split()))",
"+ dt = t - pt",
"+ dx = abs(x - px)",
"+ dy = abs(y - py)",
"+ if (dx + dy) % 2 != dt % 2:",
"+ print(\"No\")",
"+ return",
"+ if (dx + dy) > dt:",
"+ print(\"No\")",
"+ return",
"+ print(\"Yes\")",
"- n = int(eval(input()))",
"- t = list(False for _ in range(n + 1))",
"- x = list(False for _ in range(n + 1))",
"- y = list(False for _ in range(n + 1))",
"- t[0], x[0], y[0] = 0, 0, 0",
"- for i in range(n):",
"- t[i + 1], x[i + 1], y[i + 1] = list(map(int, input().split()))",
"- for i in range(1, n + 1):",
"- dt = t[i] - t[i - 1]",
"- dx = abs(x[i] - x[i - 1])",
"- dy = abs(y[i] - y[i - 1])",
"- if BlCannotGo(dt, dx, dy):",
"- print(\"No\")",
"- exit()",
"- print(\"Yes\")",
"+ main()"
] | false
| 0.041624
| 0.136183
| 0.305648
|
[
"s773830075",
"s996543613"
] |
u312025627
|
p03805
|
python
|
s929646781
|
s942724353
| 194
| 69
| 39,536
| 67,460
|
Accepted
|
Accepted
| 64.43
|
def main():
N, M = (int(i) for i in input().split())
edge = [set() for _ in range(N)]
for i in range(M):
a, b = (int(i) for i in input().split())
edge[a-1].add(b-1)
edge[b-1].add(a-1)
from itertools import permutations
ans = 0
for p in permutations(list(range(1, N))):
u = 0
for v in p:
if v not in edge[u]:
break
u = v
else:
ans += 1
print(ans)
if __name__ == '__main__':
main()
|
def main():
import sys
input = sys.stdin.buffer.readline
from itertools import permutations
N, M = (int(i) for i in input().split())
edge = [[] for _ in range(N)]
for i in range(M):
a, b = (int(i) for i in input().split())
edge[a-1].append(b-1)
edge[b-1].append(a-1)
ans = 0
for p in permutations(list(range(1, N))):
v = 0
for nv in p:
if nv in edge[v]:
v = nv
else:
break
else:
ans += 1
print(ans)
if __name__ == '__main__':
main()
| 22
| 26
| 529
| 611
|
def main():
N, M = (int(i) for i in input().split())
edge = [set() for _ in range(N)]
for i in range(M):
a, b = (int(i) for i in input().split())
edge[a - 1].add(b - 1)
edge[b - 1].add(a - 1)
from itertools import permutations
ans = 0
for p in permutations(list(range(1, N))):
u = 0
for v in p:
if v not in edge[u]:
break
u = v
else:
ans += 1
print(ans)
if __name__ == "__main__":
main()
|
def main():
import sys
input = sys.stdin.buffer.readline
from itertools import permutations
N, M = (int(i) for i in input().split())
edge = [[] for _ in range(N)]
for i in range(M):
a, b = (int(i) for i in input().split())
edge[a - 1].append(b - 1)
edge[b - 1].append(a - 1)
ans = 0
for p in permutations(list(range(1, N))):
v = 0
for nv in p:
if nv in edge[v]:
v = nv
else:
break
else:
ans += 1
print(ans)
if __name__ == "__main__":
main()
| false
| 15.384615
|
[
"+ import sys",
"+",
"+ input = sys.stdin.buffer.readline",
"+ from itertools import permutations",
"+",
"- edge = [set() for _ in range(N)]",
"+ edge = [[] for _ in range(N)]",
"- edge[a - 1].add(b - 1)",
"- edge[b - 1].add(a - 1)",
"- from itertools import permutations",
"-",
"+ edge[a - 1].append(b - 1)",
"+ edge[b - 1].append(a - 1)",
"- u = 0",
"- for v in p:",
"- if v not in edge[u]:",
"+ v = 0",
"+ for nv in p:",
"+ if nv in edge[v]:",
"+ v = nv",
"+ else:",
"- u = v"
] | false
| 0.035151
| 0.007019
| 5.007934
|
[
"s929646781",
"s942724353"
] |
u790710233
|
p02901
|
python
|
s448440871
|
s422871687
| 1,452
| 1,237
| 3,444
| 3,188
|
Accepted
|
Accepted
| 14.81
|
from itertools import product
import sys
input = sys.stdin.readline
n, m = list(map(int, input().split()))
can_open = []
cost = []
for _ in range(m):
a, b = list(map(int, input().split()))
cost.append(a)
can_open.append(sum(1 << (c-1) for c in map(int, input().split())))
n_bit = 1 << n
INF = 10**18
dp = [INF]*n_bit
dp[0] = 0
for j, (x, y) in product(list(range(n_bit)), list(zip(can_open, cost))):
m = j | x
z = dp[j]+y
if dp[m] > z:
dp[m] = z
print((dp[-1] if dp[-1] != INF else -1))
|
n, m = list(map(int, input().split()))
can_open = []
cost = []
for _ in range(m):
a, b = list(map(int, input().split()))
cost.append(a)
can_open.append(sum(1 << (c-1) for c in map(int, input().split())))
n_bit = 1 << n
INF = 10**18
dp = [INF]*n_bit
dp[0] = 0
for x, y in zip(can_open, cost):
for j in range(n_bit):
m = j | x
z = dp[j]+y
if dp[m] > z:
dp[m] = z
print((dp[-1] if dp[-1] != INF else -1))
| 23
| 21
| 518
| 463
|
from itertools import product
import sys
input = sys.stdin.readline
n, m = list(map(int, input().split()))
can_open = []
cost = []
for _ in range(m):
a, b = list(map(int, input().split()))
cost.append(a)
can_open.append(sum(1 << (c - 1) for c in map(int, input().split())))
n_bit = 1 << n
INF = 10**18
dp = [INF] * n_bit
dp[0] = 0
for j, (x, y) in product(list(range(n_bit)), list(zip(can_open, cost))):
m = j | x
z = dp[j] + y
if dp[m] > z:
dp[m] = z
print((dp[-1] if dp[-1] != INF else -1))
|
n, m = list(map(int, input().split()))
can_open = []
cost = []
for _ in range(m):
a, b = list(map(int, input().split()))
cost.append(a)
can_open.append(sum(1 << (c - 1) for c in map(int, input().split())))
n_bit = 1 << n
INF = 10**18
dp = [INF] * n_bit
dp[0] = 0
for x, y in zip(can_open, cost):
for j in range(n_bit):
m = j | x
z = dp[j] + y
if dp[m] > z:
dp[m] = z
print((dp[-1] if dp[-1] != INF else -1))
| false
| 8.695652
|
[
"-from itertools import product",
"-import sys",
"-",
"-input = sys.stdin.readline",
"-for j, (x, y) in product(list(range(n_bit)), list(zip(can_open, cost))):",
"- m = j | x",
"- z = dp[j] + y",
"- if dp[m] > z:",
"- dp[m] = z",
"+for x, y in zip(can_open, cost):",
"+ for j in range(n_bit):",
"+ m = j | x",
"+ z = dp[j] + y",
"+ if dp[m] > z:",
"+ dp[m] = z"
] | false
| 0.049506
| 0.05073
| 0.97586
|
[
"s448440871",
"s422871687"
] |
u905582793
|
p03305
|
python
|
s745132362
|
s055515527
| 1,361
| 1,093
| 123,736
| 123,612
|
Accepted
|
Accepted
| 19.69
|
n,m,s,t = map(int,input().split())
uvab = [list(map(int,input().split())) for i in range(m)]
gyen = [[] for i in range(n+1)]
gsnu = [[] for i in range(n+1)]
for u,v,a,b in uvab:
gyen[u].append((v,a))
gyen[v].append((u,a))
gsnu[u].append((v,b))
gsnu[v].append((u,b))
import heapq as hq
def dijkstra(start,graph):
dist = [10**18]*(n+1)
dist[start] = 0
q = [(0,start)]
hq.heapify(q)
while q:
_,x = hq.heappop(q)
for y,dd in graph[x]:
if dist[y] > dist[x]+dd:
dist[y] = dist[x]+dd
hq.heappush(q,(dist[y],y))
return dist
distyen = dijkstra(s,gyen)
distsnu = dijkstra(t,gsnu)
ans = []
for i in range(n,0,-1):
x = 10**15-(distyen[i]+distsnu[i])
if i == n:
ans.append(x)
else:
ans.append(max(ans[-1],x))
ans = ans[::-1]
print(*ans,sep="\n")
|
import sys
input = sys.stdin.readline
n,m,s,t = map(int,input().split())
uvab = [list(map(int,input().split())) for i in range(m)]
gyen = [[] for i in range(n+1)]
gsnu = [[] for i in range(n+1)]
for u,v,a,b in uvab:
gyen[u].append((v,a))
gyen[v].append((u,a))
gsnu[u].append((v,b))
gsnu[v].append((u,b))
import heapq as hq
def dijkstra(start,graph):
dist = [10**18]*(n+1)
dist[start] = 0
q = [(0,start)]
hq.heapify(q)
while q:
_,x = hq.heappop(q)
for y,dd in graph[x]:
if dist[y] > dist[x]+dd:
dist[y] = dist[x]+dd
hq.heappush(q,(dist[y],y))
return dist
distyen = dijkstra(s,gyen)
distsnu = dijkstra(t,gsnu)
ans = []
for i in range(n,0,-1):
x = 10**15-(distyen[i]+distsnu[i])
if i == n:
ans.append(x)
else:
ans.append(max(ans[-1],x))
ans = ans[::-1]
print(*ans,sep="\n")
| 33
| 35
| 828
| 868
|
n, m, s, t = map(int, input().split())
uvab = [list(map(int, input().split())) for i in range(m)]
gyen = [[] for i in range(n + 1)]
gsnu = [[] for i in range(n + 1)]
for u, v, a, b in uvab:
gyen[u].append((v, a))
gyen[v].append((u, a))
gsnu[u].append((v, b))
gsnu[v].append((u, b))
import heapq as hq
def dijkstra(start, graph):
dist = [10**18] * (n + 1)
dist[start] = 0
q = [(0, start)]
hq.heapify(q)
while q:
_, x = hq.heappop(q)
for y, dd in graph[x]:
if dist[y] > dist[x] + dd:
dist[y] = dist[x] + dd
hq.heappush(q, (dist[y], y))
return dist
distyen = dijkstra(s, gyen)
distsnu = dijkstra(t, gsnu)
ans = []
for i in range(n, 0, -1):
x = 10**15 - (distyen[i] + distsnu[i])
if i == n:
ans.append(x)
else:
ans.append(max(ans[-1], x))
ans = ans[::-1]
print(*ans, sep="\n")
|
import sys
input = sys.stdin.readline
n, m, s, t = map(int, input().split())
uvab = [list(map(int, input().split())) for i in range(m)]
gyen = [[] for i in range(n + 1)]
gsnu = [[] for i in range(n + 1)]
for u, v, a, b in uvab:
gyen[u].append((v, a))
gyen[v].append((u, a))
gsnu[u].append((v, b))
gsnu[v].append((u, b))
import heapq as hq
def dijkstra(start, graph):
dist = [10**18] * (n + 1)
dist[start] = 0
q = [(0, start)]
hq.heapify(q)
while q:
_, x = hq.heappop(q)
for y, dd in graph[x]:
if dist[y] > dist[x] + dd:
dist[y] = dist[x] + dd
hq.heappush(q, (dist[y], y))
return dist
distyen = dijkstra(s, gyen)
distsnu = dijkstra(t, gsnu)
ans = []
for i in range(n, 0, -1):
x = 10**15 - (distyen[i] + distsnu[i])
if i == n:
ans.append(x)
else:
ans.append(max(ans[-1], x))
ans = ans[::-1]
print(*ans, sep="\n")
| false
| 5.714286
|
[
"+import sys",
"+",
"+input = sys.stdin.readline"
] | false
| 0.040075
| 0.040829
| 0.981523
|
[
"s745132362",
"s055515527"
] |
u401487574
|
p03436
|
python
|
s391059432
|
s514886406
| 52
| 25
| 3,952
| 3,316
|
Accepted
|
Accepted
| 51.92
|
import queue
h,w = list(map(int,input().split()))
s = [list(eval(input())) for i in range(h)]
q = queue.Queue()
ma = [[0]*w for i in range(h)]
dyx = [[0,1],[0,-1],[1,0],[-1,0]]
white = 0
black = 0
for i in range(h):
white += s[i].count(".")
black = h*w - white
q.put([0,0])
s[0][0] = "#"
flag = True
while flag:
newq = queue.Queue()
while not q.empty():
y,x = q.get()
for dy,dx in dyx:
if 0 <= y + dy< h and 0 <= x +dx <w and s[y+dy][x+dx] != "#":
s[y+dy][x+dx] = "#"
newq.put([y+dy,x+dx])
ma[y+dy][x+dx] = ma[y][x] +1
if y+dy == h-1 and x+dx == w-1:
flag = False
q = newq
if q.empty():
break
if ma[h-1][w-1] == 0:
print((-1))
else:print((white - ma[h-1][w-1]-1))
|
from collections import deque
def BFS_grid(grid,visited,start,goal):
y,x = start
visited[y][x] = 1
q = deque([start])
delta = [[-1,0],[0,-1],[1,0],[0,1]]
h = len(grid)
w = len(grid[0])
flag = False
while q:
y,x = q.popleft()
for dy,dx in delta:
if (0<= x+dx < w) and (0<= y+dy<h) :
if visited[y+dy][x+dx] == 0 and grid[y+dy][x+dx]==".":
visited[y+dy][x+dx] = visited[y][x] +1
q.append([y+dy,x+dx])
if [y+dy,x+dx] == goal:
flag = True
return flag
h,w = list(map(int,input().split()))
mz = []
white = 0
for i in range(h):
mz.append(list(eval(input())))
white += mz[-1].count(".")
visited = [[0]*w for i in range(h)]
if BFS_grid(mz,visited,[0,0],[h-1,w-1]):
print((white - (visited[h-1][w-1]-visited[0][0]+1)))
else:
print((-1))
| 31
| 34
| 814
| 927
|
import queue
h, w = list(map(int, input().split()))
s = [list(eval(input())) for i in range(h)]
q = queue.Queue()
ma = [[0] * w for i in range(h)]
dyx = [[0, 1], [0, -1], [1, 0], [-1, 0]]
white = 0
black = 0
for i in range(h):
white += s[i].count(".")
black = h * w - white
q.put([0, 0])
s[0][0] = "#"
flag = True
while flag:
newq = queue.Queue()
while not q.empty():
y, x = q.get()
for dy, dx in dyx:
if 0 <= y + dy < h and 0 <= x + dx < w and s[y + dy][x + dx] != "#":
s[y + dy][x + dx] = "#"
newq.put([y + dy, x + dx])
ma[y + dy][x + dx] = ma[y][x] + 1
if y + dy == h - 1 and x + dx == w - 1:
flag = False
q = newq
if q.empty():
break
if ma[h - 1][w - 1] == 0:
print((-1))
else:
print((white - ma[h - 1][w - 1] - 1))
|
from collections import deque
def BFS_grid(grid, visited, start, goal):
y, x = start
visited[y][x] = 1
q = deque([start])
delta = [[-1, 0], [0, -1], [1, 0], [0, 1]]
h = len(grid)
w = len(grid[0])
flag = False
while q:
y, x = q.popleft()
for dy, dx in delta:
if (0 <= x + dx < w) and (0 <= y + dy < h):
if visited[y + dy][x + dx] == 0 and grid[y + dy][x + dx] == ".":
visited[y + dy][x + dx] = visited[y][x] + 1
q.append([y + dy, x + dx])
if [y + dy, x + dx] == goal:
flag = True
return flag
h, w = list(map(int, input().split()))
mz = []
white = 0
for i in range(h):
mz.append(list(eval(input())))
white += mz[-1].count(".")
visited = [[0] * w for i in range(h)]
if BFS_grid(mz, visited, [0, 0], [h - 1, w - 1]):
print((white - (visited[h - 1][w - 1] - visited[0][0] + 1)))
else:
print((-1))
| false
| 8.823529
|
[
"-import queue",
"+from collections import deque",
"+",
"+",
"+def BFS_grid(grid, visited, start, goal):",
"+ y, x = start",
"+ visited[y][x] = 1",
"+ q = deque([start])",
"+ delta = [[-1, 0], [0, -1], [1, 0], [0, 1]]",
"+ h = len(grid)",
"+ w = len(grid[0])",
"+ flag = False",
"+ while q:",
"+ y, x = q.popleft()",
"+ for dy, dx in delta:",
"+ if (0 <= x + dx < w) and (0 <= y + dy < h):",
"+ if visited[y + dy][x + dx] == 0 and grid[y + dy][x + dx] == \".\":",
"+ visited[y + dy][x + dx] = visited[y][x] + 1",
"+ q.append([y + dy, x + dx])",
"+ if [y + dy, x + dx] == goal:",
"+ flag = True",
"+ return flag",
"+",
"-s = [list(eval(input())) for i in range(h)]",
"-q = queue.Queue()",
"-ma = [[0] * w for i in range(h)]",
"-dyx = [[0, 1], [0, -1], [1, 0], [-1, 0]]",
"+mz = []",
"-black = 0",
"- white += s[i].count(\".\")",
"-black = h * w - white",
"-q.put([0, 0])",
"-s[0][0] = \"#\"",
"-flag = True",
"-while flag:",
"- newq = queue.Queue()",
"- while not q.empty():",
"- y, x = q.get()",
"- for dy, dx in dyx:",
"- if 0 <= y + dy < h and 0 <= x + dx < w and s[y + dy][x + dx] != \"#\":",
"- s[y + dy][x + dx] = \"#\"",
"- newq.put([y + dy, x + dx])",
"- ma[y + dy][x + dx] = ma[y][x] + 1",
"- if y + dy == h - 1 and x + dx == w - 1:",
"- flag = False",
"- q = newq",
"- if q.empty():",
"- break",
"-if ma[h - 1][w - 1] == 0:",
"+ mz.append(list(eval(input())))",
"+ white += mz[-1].count(\".\")",
"+visited = [[0] * w for i in range(h)]",
"+if BFS_grid(mz, visited, [0, 0], [h - 1, w - 1]):",
"+ print((white - (visited[h - 1][w - 1] - visited[0][0] + 1)))",
"+else:",
"-else:",
"- print((white - ma[h - 1][w - 1] - 1))"
] | false
| 0.074547
| 0.036712
| 2.030596
|
[
"s391059432",
"s514886406"
] |
u546338822
|
p03032
|
python
|
s150882859
|
s559785844
| 484
| 45
| 3,064
| 9,368
|
Accepted
|
Accepted
| 90.7
|
def main():
n,k = list(map(int,input().split()))
v = list(map(int,input().split()))
m = 0
for k_ in range(k+1):
v_c = v
if k_>n:
v_ = v_c
v_c = []
s = k-n
else:
v_ = v_c[0:k_]
v_c = v_c[k_:]
s = k-k_
for i in range(s+1):
if i>len(v_c):
v__ =v_+ v_c
s_ = s-len(v_c)
else:
v__ = v_+ v_c[len(v_c)-i:]
s_ = s-i
while s_>0 and len(v__)>0 and min(v__)<0:
v__.pop(v__.index(min(v__)))
s_ = s_-1
if sum(v__)>m:
m = sum(v__)
print(m)
if __name__ == "__main__":
main()
|
def main():
import copy
n,k = list(map(int,input().split()))
v = list(map(int,input().split()))
ans = 0
for i in range(min(n+1,k+1)):
t = v[0:i]
for j in range(min(n-i+1,k-i+1)):
t_ = copy.deepcopy(t)
t_ += v[n-j:n]
r = k-i-j
t_ = sorted(t_)
cnt = 0
for l in range(len(t_)):
if t_[l]<0 and cnt<r:
t_[l] = 0
cnt += 1
else:
break
if ans<sum(t_):
ans = sum(t_)
print(ans)
if __name__ == "__main__":
main()
| 30
| 26
| 770
| 672
|
def main():
n, k = list(map(int, input().split()))
v = list(map(int, input().split()))
m = 0
for k_ in range(k + 1):
v_c = v
if k_ > n:
v_ = v_c
v_c = []
s = k - n
else:
v_ = v_c[0:k_]
v_c = v_c[k_:]
s = k - k_
for i in range(s + 1):
if i > len(v_c):
v__ = v_ + v_c
s_ = s - len(v_c)
else:
v__ = v_ + v_c[len(v_c) - i :]
s_ = s - i
while s_ > 0 and len(v__) > 0 and min(v__) < 0:
v__.pop(v__.index(min(v__)))
s_ = s_ - 1
if sum(v__) > m:
m = sum(v__)
print(m)
if __name__ == "__main__":
main()
|
def main():
import copy
n, k = list(map(int, input().split()))
v = list(map(int, input().split()))
ans = 0
for i in range(min(n + 1, k + 1)):
t = v[0:i]
for j in range(min(n - i + 1, k - i + 1)):
t_ = copy.deepcopy(t)
t_ += v[n - j : n]
r = k - i - j
t_ = sorted(t_)
cnt = 0
for l in range(len(t_)):
if t_[l] < 0 and cnt < r:
t_[l] = 0
cnt += 1
else:
break
if ans < sum(t_):
ans = sum(t_)
print(ans)
if __name__ == "__main__":
main()
| false
| 13.333333
|
[
"+ import copy",
"+",
"- m = 0",
"- for k_ in range(k + 1):",
"- v_c = v",
"- if k_ > n:",
"- v_ = v_c",
"- v_c = []",
"- s = k - n",
"- else:",
"- v_ = v_c[0:k_]",
"- v_c = v_c[k_:]",
"- s = k - k_",
"- for i in range(s + 1):",
"- if i > len(v_c):",
"- v__ = v_ + v_c",
"- s_ = s - len(v_c)",
"- else:",
"- v__ = v_ + v_c[len(v_c) - i :]",
"- s_ = s - i",
"- while s_ > 0 and len(v__) > 0 and min(v__) < 0:",
"- v__.pop(v__.index(min(v__)))",
"- s_ = s_ - 1",
"- if sum(v__) > m:",
"- m = sum(v__)",
"- print(m)",
"+ ans = 0",
"+ for i in range(min(n + 1, k + 1)):",
"+ t = v[0:i]",
"+ for j in range(min(n - i + 1, k - i + 1)):",
"+ t_ = copy.deepcopy(t)",
"+ t_ += v[n - j : n]",
"+ r = k - i - j",
"+ t_ = sorted(t_)",
"+ cnt = 0",
"+ for l in range(len(t_)):",
"+ if t_[l] < 0 and cnt < r:",
"+ t_[l] = 0",
"+ cnt += 1",
"+ else:",
"+ break",
"+ if ans < sum(t_):",
"+ ans = sum(t_)",
"+ print(ans)"
] | false
| 0.035005
| 0.036991
| 0.946315
|
[
"s150882859",
"s559785844"
] |
u977389981
|
p02993
|
python
|
s249529964
|
s111964180
| 171
| 18
| 38,384
| 2,940
|
Accepted
|
Accepted
| 89.47
|
S = eval(input())
for i in range(len(S) - 1):
if S[i] == S[i + 1]:
print('Bad')
break
else:
print('Good')
|
S = eval(input())
for i in range(3):
if S[i] != S[i + 1]:
continue
else:
print('Bad')
break
else:
print('Good')
| 7
| 10
| 129
| 151
|
S = eval(input())
for i in range(len(S) - 1):
if S[i] == S[i + 1]:
print("Bad")
break
else:
print("Good")
|
S = eval(input())
for i in range(3):
if S[i] != S[i + 1]:
continue
else:
print("Bad")
break
else:
print("Good")
| false
| 30
|
[
"-for i in range(len(S) - 1):",
"- if S[i] == S[i + 1]:",
"+for i in range(3):",
"+ if S[i] != S[i + 1]:",
"+ continue",
"+ else:"
] | false
| 0.154545
| 0.043864
| 3.523263
|
[
"s249529964",
"s111964180"
] |
u569960318
|
p02264
|
python
|
s628124374
|
s104154175
| 770
| 320
| 24,368
| 24,688
|
Accepted
|
Accepted
| 58.44
|
n,q = list(map(int, input().split()))
P = [[p,int(t)] for p,t in [input().split() for _ in range(n)]]
time = 0
while len(P) > 0:
pi = P.pop(0)
if pi[1] > q:
P.append([pi[0],pi[1]-q])
time += q
else:
time += pi[1]
print((pi[0],time))
|
from collections import deque
n,q = list(map(int, input().split()))
P = deque([[p,int(t)] for p,t in [input().split() for _ in range(n)]])
time = 0
while len(P) > 0:
pi = P.popleft()
if pi[1] > q:
P.append([pi[0],pi[1]-q])
time += q
else:
time += pi[1]
print((pi[0],time))
| 11
| 12
| 284
| 325
|
n, q = list(map(int, input().split()))
P = [[p, int(t)] for p, t in [input().split() for _ in range(n)]]
time = 0
while len(P) > 0:
pi = P.pop(0)
if pi[1] > q:
P.append([pi[0], pi[1] - q])
time += q
else:
time += pi[1]
print((pi[0], time))
|
from collections import deque
n, q = list(map(int, input().split()))
P = deque([[p, int(t)] for p, t in [input().split() for _ in range(n)]])
time = 0
while len(P) > 0:
pi = P.popleft()
if pi[1] > q:
P.append([pi[0], pi[1] - q])
time += q
else:
time += pi[1]
print((pi[0], time))
| false
| 8.333333
|
[
"+from collections import deque",
"+",
"-P = [[p, int(t)] for p, t in [input().split() for _ in range(n)]]",
"+P = deque([[p, int(t)] for p, t in [input().split() for _ in range(n)]])",
"- pi = P.pop(0)",
"+ pi = P.popleft()"
] | false
| 0.037343
| 0.072319
| 0.516356
|
[
"s628124374",
"s104154175"
] |
u439396449
|
p03700
|
python
|
s635745365
|
s631716715
| 1,668
| 871
| 7,068
| 7,068
|
Accepted
|
Accepted
| 47.78
|
import math
N, A, B = list(map(int, input().split()))
h = [int(eval(input())) for _ in range(N)]
def check(t):
cnt = 0
ab = A - B
bt = B * t
for i in range(N):
cnt += max(0, math.ceil((h[i] - bt) / ab))
return cnt <= t
left = 1
right = max(h)
while right - left > 1:
mid = (left + right) // 2
if check(mid):
right = mid
else:
left = mid
print(right)
|
import math
N, A, B = list(map(int, input().split()))
h = [int(eval(input())) for _ in range(N)]
def check(t):
cnt = 0
ab = A - B
bt = B * t
for i in range(N):
r = (h[i] - bt)
if r <= 0:
continue
cnt += r // ab
if r % ab:
cnt += 1
return cnt <= t
left = 1
right = max(h)
while right - left > 1:
mid = (left + right) // 2
if check(mid):
right = mid
else:
left = mid
print(right)
| 24
| 29
| 422
| 503
|
import math
N, A, B = list(map(int, input().split()))
h = [int(eval(input())) for _ in range(N)]
def check(t):
cnt = 0
ab = A - B
bt = B * t
for i in range(N):
cnt += max(0, math.ceil((h[i] - bt) / ab))
return cnt <= t
left = 1
right = max(h)
while right - left > 1:
mid = (left + right) // 2
if check(mid):
right = mid
else:
left = mid
print(right)
|
import math
N, A, B = list(map(int, input().split()))
h = [int(eval(input())) for _ in range(N)]
def check(t):
cnt = 0
ab = A - B
bt = B * t
for i in range(N):
r = h[i] - bt
if r <= 0:
continue
cnt += r // ab
if r % ab:
cnt += 1
return cnt <= t
left = 1
right = max(h)
while right - left > 1:
mid = (left + right) // 2
if check(mid):
right = mid
else:
left = mid
print(right)
| false
| 17.241379
|
[
"- cnt += max(0, math.ceil((h[i] - bt) / ab))",
"+ r = h[i] - bt",
"+ if r <= 0:",
"+ continue",
"+ cnt += r // ab",
"+ if r % ab:",
"+ cnt += 1"
] | false
| 0.038057
| 0.036313
| 1.048012
|
[
"s635745365",
"s631716715"
] |
u838644735
|
p03062
|
python
|
s678550269
|
s858909851
| 78
| 72
| 14,412
| 14,224
|
Accepted
|
Accepted
| 7.69
|
def main():
N = int(eval(input()))
A = list(map(int, input().split()))
negatives = 0
zeros = 0
min_abs = 10**9 + 1
for a in A:
if a < 0:
negatives += 1
if a == zeros:
zeros += 1
min_abs = min(min_abs, abs(a))
ans = sum(map(abs, A))
if negatives % 2 == 0 or zeros != 0:
print(ans)
return
ans -= 2*min_abs
print(ans)
if __name__ == '__main__':
main()
|
def main():
N = int(eval(input()))
A = list(map(int, input().split()))
negatives = 0
zeros = 0
min_abs = 10**9 + 1
for a in A:
if a < 0:
negatives += 1
if a == 0:
zeros += 1
min_abs = min(min_abs, abs(a))
ans = sum(map(abs, A))
if negatives % 2 == 0 or zeros != 0:
print(ans)
return
ans -= 2*min_abs
print(ans)
if __name__ == '__main__':
main()
| 22
| 22
| 474
| 470
|
def main():
N = int(eval(input()))
A = list(map(int, input().split()))
negatives = 0
zeros = 0
min_abs = 10**9 + 1
for a in A:
if a < 0:
negatives += 1
if a == zeros:
zeros += 1
min_abs = min(min_abs, abs(a))
ans = sum(map(abs, A))
if negatives % 2 == 0 or zeros != 0:
print(ans)
return
ans -= 2 * min_abs
print(ans)
if __name__ == "__main__":
main()
|
def main():
N = int(eval(input()))
A = list(map(int, input().split()))
negatives = 0
zeros = 0
min_abs = 10**9 + 1
for a in A:
if a < 0:
negatives += 1
if a == 0:
zeros += 1
min_abs = min(min_abs, abs(a))
ans = sum(map(abs, A))
if negatives % 2 == 0 or zeros != 0:
print(ans)
return
ans -= 2 * min_abs
print(ans)
if __name__ == "__main__":
main()
| false
| 0
|
[
"- if a == zeros:",
"+ if a == 0:"
] | false
| 0.040769
| 0.039226
| 1.039335
|
[
"s678550269",
"s858909851"
] |
u679325651
|
p02861
|
python
|
s673774977
|
s253980344
| 125
| 18
| 4,400
| 3,064
|
Accepted
|
Accepted
| 85.6
|
import itertools
import math
N = int(eval(input()))
xy = [[int(i) for i in input().split()] for j in range(N)]
distance = [[0 for j in range(N)] for i in range(N)]
for i in range(N):
for j in range(N):
xi = xy[i][0]
yi = xy[i][1]
xj = xy[j][0]
yj = xy[j][1]
d = math.sqrt((xi-xj)**2+(yi-yj)**2)
distance[i][j] = d
distance[j][i] = d
anslist=[]
for route in itertools.permutations(list(range(N)),N):
total=0
for i in range(N-1):
start = route[i]
goal = route[j]
total += distance[start][goal]
anslist.append(total)
print((sum(anslist)/len(anslist)))
|
import itertools
import math
N = int(eval(input()))
xy = [[int(i) for i in input().split()] for j in range(N)]
distance = [[0 for j in range(N)] for i in range(N)]
for i in range(N):
for j in range(N):
xi = xy[i][0]
yi = xy[i][1]
xj = xy[j][0]
yj = xy[j][1]
d = math.sqrt((xi-xj)**2+(yi-yj)**2)
distance[i][j] = d
distance[j][i] = d
print((sum([sum(i) for i in distance])/N))
| 26
| 17
| 659
| 447
|
import itertools
import math
N = int(eval(input()))
xy = [[int(i) for i in input().split()] for j in range(N)]
distance = [[0 for j in range(N)] for i in range(N)]
for i in range(N):
for j in range(N):
xi = xy[i][0]
yi = xy[i][1]
xj = xy[j][0]
yj = xy[j][1]
d = math.sqrt((xi - xj) ** 2 + (yi - yj) ** 2)
distance[i][j] = d
distance[j][i] = d
anslist = []
for route in itertools.permutations(list(range(N)), N):
total = 0
for i in range(N - 1):
start = route[i]
goal = route[j]
total += distance[start][goal]
anslist.append(total)
print((sum(anslist) / len(anslist)))
|
import itertools
import math
N = int(eval(input()))
xy = [[int(i) for i in input().split()] for j in range(N)]
distance = [[0 for j in range(N)] for i in range(N)]
for i in range(N):
for j in range(N):
xi = xy[i][0]
yi = xy[i][1]
xj = xy[j][0]
yj = xy[j][1]
d = math.sqrt((xi - xj) ** 2 + (yi - yj) ** 2)
distance[i][j] = d
distance[j][i] = d
print((sum([sum(i) for i in distance]) / N))
| false
| 34.615385
|
[
"-anslist = []",
"-for route in itertools.permutations(list(range(N)), N):",
"- total = 0",
"- for i in range(N - 1):",
"- start = route[i]",
"- goal = route[j]",
"- total += distance[start][goal]",
"- anslist.append(total)",
"-print((sum(anslist) / len(anslist)))",
"+print((sum([sum(i) for i in distance]) / N))"
] | false
| 0.049937
| 0.08645
| 0.577639
|
[
"s673774977",
"s253980344"
] |
u735335967
|
p02778
|
python
|
s178288453
|
s657463436
| 22
| 17
| 3,188
| 2,940
|
Accepted
|
Accepted
| 22.73
|
import re
s = eval(input())
print((len(s) * "x"))
|
msg = eval(input())
y = ''
for i in range(len(msg)):
y += 'x'
print(y)
| 4
| 5
| 46
| 73
|
import re
s = eval(input())
print((len(s) * "x"))
|
msg = eval(input())
y = ""
for i in range(len(msg)):
y += "x"
print(y)
| false
| 20
|
[
"-import re",
"-",
"-s = eval(input())",
"-print((len(s) * \"x\"))",
"+msg = eval(input())",
"+y = \"\"",
"+for i in range(len(msg)):",
"+ y += \"x\"",
"+print(y)"
] | false
| 0.03919
| 0.040191
| 0.9751
|
[
"s178288453",
"s657463436"
] |
u102461423
|
p03839
|
python
|
s741289518
|
s434736710
| 1,007
| 133
| 119,600
| 33,664
|
Accepted
|
Accepted
| 86.79
|
import sys
import numpy as np
from numba import njit
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N, K = list(map(int, readline().split()))
A = np.array(read().split(), np.int64)
@njit('(i8,i8,i8[:])', cache=True)
def main(N, K, A):
B = np.maximum(A, 0)
Acum = np.zeros(len(A) + 1, np.int64)
Bcum = np.zeros(len(A) + 1, np.int64)
Acum[1:] = np.cumsum(A)
Bcum[1:] = np.cumsum(B)
ret = -(10**18)
for l in range(N - K + 1):
r = l + K
sum1 = Bcum[l]
sum2 = Bcum[-1] - Bcum[r]
sum3 = Acum[r] - Acum[l]
x = sum1 + sum2 + max(sum3, 0)
ret = max(ret, x)
return ret
print((main(N, K, A)))
|
import sys
import numpy as np
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N, K = list(map(int, readline().split()))
A = np.array(read().split(), np.int64)
def main(N, K, A):
B = np.maximum(A, 0)
Acum = np.zeros(N + 1, np.int64)
Bcum = np.zeros(N + 1, np.int64)
Acum[1:] = np.cumsum(A)
Bcum[1:] = np.cumsum(B)
sum1 = Bcum[:N - K + 1]
sum2 = Bcum[-1] - Bcum[K:]
sum3 = Acum[K:] - Acum[:N - K + 1]
x = sum1 + sum2 + np.maximum(sum3, 0)
return x.max()
print((main(N, K, A)))
| 29
| 23
| 743
| 589
|
import sys
import numpy as np
from numba import njit
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N, K = list(map(int, readline().split()))
A = np.array(read().split(), np.int64)
@njit("(i8,i8,i8[:])", cache=True)
def main(N, K, A):
B = np.maximum(A, 0)
Acum = np.zeros(len(A) + 1, np.int64)
Bcum = np.zeros(len(A) + 1, np.int64)
Acum[1:] = np.cumsum(A)
Bcum[1:] = np.cumsum(B)
ret = -(10**18)
for l in range(N - K + 1):
r = l + K
sum1 = Bcum[l]
sum2 = Bcum[-1] - Bcum[r]
sum3 = Acum[r] - Acum[l]
x = sum1 + sum2 + max(sum3, 0)
ret = max(ret, x)
return ret
print((main(N, K, A)))
|
import sys
import numpy as np
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N, K = list(map(int, readline().split()))
A = np.array(read().split(), np.int64)
def main(N, K, A):
B = np.maximum(A, 0)
Acum = np.zeros(N + 1, np.int64)
Bcum = np.zeros(N + 1, np.int64)
Acum[1:] = np.cumsum(A)
Bcum[1:] = np.cumsum(B)
sum1 = Bcum[: N - K + 1]
sum2 = Bcum[-1] - Bcum[K:]
sum3 = Acum[K:] - Acum[: N - K + 1]
x = sum1 + sum2 + np.maximum(sum3, 0)
return x.max()
print((main(N, K, A)))
| false
| 20.689655
|
[
"-from numba import njit",
"-@njit(\"(i8,i8,i8[:])\", cache=True)",
"- Acum = np.zeros(len(A) + 1, np.int64)",
"- Bcum = np.zeros(len(A) + 1, np.int64)",
"+ Acum = np.zeros(N + 1, np.int64)",
"+ Bcum = np.zeros(N + 1, np.int64)",
"- ret = -(10**18)",
"- for l in range(N - K + 1):",
"- r = l + K",
"- sum1 = Bcum[l]",
"- sum2 = Bcum[-1] - Bcum[r]",
"- sum3 = Acum[r] - Acum[l]",
"- x = sum1 + sum2 + max(sum3, 0)",
"- ret = max(ret, x)",
"- return ret",
"+ sum1 = Bcum[: N - K + 1]",
"+ sum2 = Bcum[-1] - Bcum[K:]",
"+ sum3 = Acum[K:] - Acum[: N - K + 1]",
"+ x = sum1 + sum2 + np.maximum(sum3, 0)",
"+ return x.max()"
] | false
| 0.185582
| 0.549768
| 0.337563
|
[
"s741289518",
"s434736710"
] |
u974620347
|
p03161
|
python
|
s073873924
|
s547546600
| 440
| 314
| 52,448
| 52,448
|
Accepted
|
Accepted
| 28.64
|
def a():
N, K = [int(n) for n in input().split()]
h = [int(n) for n in input().split()]
# dp[i]はi番目までたどり着くのに必要な最小コスト
# dp[0] = 0
# dp[1] = |h[1] - h[0]|
# dp[i] = min(dp[0]+h[i]-h[0], dp[1]+h[i]-h[1], ...)
dp = [0] * N
dp[0] = 0
dp[1] = abs(h[1] - h[0])
for i in range(2, N):
dp[i] = min([dp[k] + abs(h[k] - h[i]) for k in range(max(i - K, 0), i)])
print((dp[N-1]))
if __name__ == "__main__":
a()
|
def main():
N, K = [int(i) for i in input().split()]
A = [int(i) for i in input().split()]
dp = [-1]*N
dp[0] = 0
for i in range(1,N):
res = -1
for j in range(1, K+1):
if i - j < 0:
break
new = dp[i-j] + abs(A[i] - A[i-j])
if res == -1:
res = new
continue
res = min(res, new)
dp[i] = res
print((dp[N-1]))
main()
| 16
| 18
| 466
| 469
|
def a():
N, K = [int(n) for n in input().split()]
h = [int(n) for n in input().split()]
# dp[i]はi番目までたどり着くのに必要な最小コスト
# dp[0] = 0
# dp[1] = |h[1] - h[0]|
# dp[i] = min(dp[0]+h[i]-h[0], dp[1]+h[i]-h[1], ...)
dp = [0] * N
dp[0] = 0
dp[1] = abs(h[1] - h[0])
for i in range(2, N):
dp[i] = min([dp[k] + abs(h[k] - h[i]) for k in range(max(i - K, 0), i)])
print((dp[N - 1]))
if __name__ == "__main__":
a()
|
def main():
N, K = [int(i) for i in input().split()]
A = [int(i) for i in input().split()]
dp = [-1] * N
dp[0] = 0
for i in range(1, N):
res = -1
for j in range(1, K + 1):
if i - j < 0:
break
new = dp[i - j] + abs(A[i] - A[i - j])
if res == -1:
res = new
continue
res = min(res, new)
dp[i] = res
print((dp[N - 1]))
main()
| false
| 11.111111
|
[
"-def a():",
"- N, K = [int(n) for n in input().split()]",
"- h = [int(n) for n in input().split()]",
"- # dp[i]はi番目までたどり着くのに必要な最小コスト",
"- # dp[0] = 0",
"- # dp[1] = |h[1] - h[0]|",
"- # dp[i] = min(dp[0]+h[i]-h[0], dp[1]+h[i]-h[1], ...)",
"- dp = [0] * N",
"+def main():",
"+ N, K = [int(i) for i in input().split()]",
"+ A = [int(i) for i in input().split()]",
"+ dp = [-1] * N",
"- dp[1] = abs(h[1] - h[0])",
"- for i in range(2, N):",
"- dp[i] = min([dp[k] + abs(h[k] - h[i]) for k in range(max(i - K, 0), i)])",
"+ for i in range(1, N):",
"+ res = -1",
"+ for j in range(1, K + 1):",
"+ if i - j < 0:",
"+ break",
"+ new = dp[i - j] + abs(A[i] - A[i - j])",
"+ if res == -1:",
"+ res = new",
"+ continue",
"+ res = min(res, new)",
"+ dp[i] = res",
"-if __name__ == \"__main__\":",
"- a()",
"+main()"
] | false
| 0.036024
| 0.036331
| 0.991545
|
[
"s073873924",
"s547546600"
] |
u664373116
|
p02928
|
python
|
s926269668
|
s628895120
| 1,340
| 682
| 3,188
| 3,188
|
Accepted
|
Accepted
| 49.1
|
N,K=list(map(int,input().split()))
A=list(map(int,input().split()))
mod=10**9+7
b=0
f=0
for i in range(N):
for j in range(i+1,N):
if A[i]>A[j]:
#print(i,",",j)
f+=1
for i in range(N):
for j in range(N):
if i==j:
continue
if A[i]>A[j]:
b+=1
ans=f*K
tmp=((K-1)*K)//2
ans+=b*tmp
#ans = K * f + (b * K * (K - 1)) // 2
ans%=mod
print((int(ans)))
|
N,K=list(map(int,input().split()))
A=list(map(int,input().split()))
mod=10**9+7
b=0
f=0
for i in range(N):
for j in range(i+1,N):
if A[i]>A[j]:
#print(i,",",j)
f+=1
for i in range(N-1,-1,-1):
for j in range(i-1,-1,-1):
if A[i]>A[j]:
b+=1
ans=f*((K+1)*K//2)+b*((K-1)*K//2)
ans%=mod
print(ans)
| 26
| 20
| 470
| 396
|
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
mod = 10**9 + 7
b = 0
f = 0
for i in range(N):
for j in range(i + 1, N):
if A[i] > A[j]:
# print(i,",",j)
f += 1
for i in range(N):
for j in range(N):
if i == j:
continue
if A[i] > A[j]:
b += 1
ans = f * K
tmp = ((K - 1) * K) // 2
ans += b * tmp
# ans = K * f + (b * K * (K - 1)) // 2
ans %= mod
print((int(ans)))
|
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
mod = 10**9 + 7
b = 0
f = 0
for i in range(N):
for j in range(i + 1, N):
if A[i] > A[j]:
# print(i,",",j)
f += 1
for i in range(N - 1, -1, -1):
for j in range(i - 1, -1, -1):
if A[i] > A[j]:
b += 1
ans = f * ((K + 1) * K // 2) + b * ((K - 1) * K // 2)
ans %= mod
print(ans)
| false
| 23.076923
|
[
"-for i in range(N):",
"- for j in range(N):",
"- if i == j:",
"- continue",
"+for i in range(N - 1, -1, -1):",
"+ for j in range(i - 1, -1, -1):",
"-ans = f * K",
"-tmp = ((K - 1) * K) // 2",
"-ans += b * tmp",
"-# ans = K * f + (b * K * (K - 1)) // 2",
"+ans = f * ((K + 1) * K // 2) + b * ((K - 1) * K // 2)",
"-print((int(ans)))",
"+print(ans)"
] | false
| 0.117918
| 0.047381
| 2.488735
|
[
"s926269668",
"s628895120"
] |
u810356688
|
p02780
|
python
|
s665833960
|
s436210361
| 259
| 220
| 80,708
| 33,888
|
Accepted
|
Accepted
| 15.06
|
import sys
def input(): return sys.stdin.readline().rstrip()
from itertools import accumulate
def main():
n,k=list(map(int,input().split()))
P=[int(_) for _ in input().split()]
PP=[0]*n
for i in range(n):
PP[i]=(P[i]+1)/2
PP_ac=list(accumulate(PP))
ans=PP_ac[k-1]
for i in range(1,n-k+1):
ans=max(ans,PP_ac[i+k-1]-PP_ac[i-1])
print(ans)
if __name__=='__main__':
main()
|
import sys
def input(): return sys.stdin.readline().rstrip()
from itertools import accumulate
import numpy as np
def main():
n,k=list(map(int,input().split()))
P=[int(_) for _ in input().split()]
P_num=np.array(P)
PP=(P_num+1)/2
PP_cum=np.cumsum(PP)
PP_cum=np.insert(PP_cum,0,0)
ans=PP_cum[k:]-PP_cum[:n-k+1]
print((np.max(ans)))
if __name__=='__main__':
main()
| 17
| 16
| 431
| 405
|
import sys
def input():
return sys.stdin.readline().rstrip()
from itertools import accumulate
def main():
n, k = list(map(int, input().split()))
P = [int(_) for _ in input().split()]
PP = [0] * n
for i in range(n):
PP[i] = (P[i] + 1) / 2
PP_ac = list(accumulate(PP))
ans = PP_ac[k - 1]
for i in range(1, n - k + 1):
ans = max(ans, PP_ac[i + k - 1] - PP_ac[i - 1])
print(ans)
if __name__ == "__main__":
main()
|
import sys
def input():
return sys.stdin.readline().rstrip()
from itertools import accumulate
import numpy as np
def main():
n, k = list(map(int, input().split()))
P = [int(_) for _ in input().split()]
P_num = np.array(P)
PP = (P_num + 1) / 2
PP_cum = np.cumsum(PP)
PP_cum = np.insert(PP_cum, 0, 0)
ans = PP_cum[k:] - PP_cum[: n - k + 1]
print((np.max(ans)))
if __name__ == "__main__":
main()
| false
| 5.882353
|
[
"+import numpy as np",
"- PP = [0] * n",
"- for i in range(n):",
"- PP[i] = (P[i] + 1) / 2",
"- PP_ac = list(accumulate(PP))",
"- ans = PP_ac[k - 1]",
"- for i in range(1, n - k + 1):",
"- ans = max(ans, PP_ac[i + k - 1] - PP_ac[i - 1])",
"- print(ans)",
"+ P_num = np.array(P)",
"+ PP = (P_num + 1) / 2",
"+ PP_cum = np.cumsum(PP)",
"+ PP_cum = np.insert(PP_cum, 0, 0)",
"+ ans = PP_cum[k:] - PP_cum[: n - k + 1]",
"+ print((np.max(ans)))"
] | false
| 0.038843
| 0.466228
| 0.083313
|
[
"s665833960",
"s436210361"
] |
u652656291
|
p03495
|
python
|
s423765670
|
s102898854
| 206
| 78
| 31,484
| 35,996
|
Accepted
|
Accepted
| 62.14
|
import numpy as np
N,K = list(map(int,input().split()))
A = np.array(input().split(), dtype=np.int32)
counter = np.bincount(A)
counter.sort()
counter = counter[::-1]
no_change = counter[:K].sum()
answer = N - no_change
print(answer)
|
import collections
n,k = list(map(int,input().split()))
a = input().split()
a = sorted(list(collections.Counter(a).values()))
print((sum(a[:len(a)-k])))
| 9
| 5
| 236
| 149
|
import numpy as np
N, K = list(map(int, input().split()))
A = np.array(input().split(), dtype=np.int32)
counter = np.bincount(A)
counter.sort()
counter = counter[::-1]
no_change = counter[:K].sum()
answer = N - no_change
print(answer)
|
import collections
n, k = list(map(int, input().split()))
a = input().split()
a = sorted(list(collections.Counter(a).values()))
print((sum(a[: len(a) - k])))
| false
| 44.444444
|
[
"-import numpy as np",
"+import collections",
"-N, K = list(map(int, input().split()))",
"-A = np.array(input().split(), dtype=np.int32)",
"-counter = np.bincount(A)",
"-counter.sort()",
"-counter = counter[::-1]",
"-no_change = counter[:K].sum()",
"-answer = N - no_change",
"-print(answer)",
"+n, k = list(map(int, input().split()))",
"+a = input().split()",
"+a = sorted(list(collections.Counter(a).values()))",
"+print((sum(a[: len(a) - k])))"
] | false
| 0.155669
| 0.073636
| 2.114042
|
[
"s423765670",
"s102898854"
] |
u218834617
|
p02584
|
python
|
s191963267
|
s968004725
| 34
| 28
| 9,152
| 9,044
|
Accepted
|
Accepted
| 17.65
|
X,K,D=list(map(int,input().split()))
X=abs(X)
a=min(K,X//D)
X-=a*D
K-=a
#print(X,K)
if K%2:
X=abs(X-D)
ans=X
print(ans)
|
X,K,D=list(map(int,input().split()))
X=abs(X)
a=min(K,X//D)
ans=X-a*D
if (K-a)%2:
ans=D-ans
print(ans)
| 11
| 9
| 129
| 111
|
X, K, D = list(map(int, input().split()))
X = abs(X)
a = min(K, X // D)
X -= a * D
K -= a
# print(X,K)
if K % 2:
X = abs(X - D)
ans = X
print(ans)
|
X, K, D = list(map(int, input().split()))
X = abs(X)
a = min(K, X // D)
ans = X - a * D
if (K - a) % 2:
ans = D - ans
print(ans)
| false
| 18.181818
|
[
"-X -= a * D",
"-K -= a",
"-# print(X,K)",
"-if K % 2:",
"- X = abs(X - D)",
"-ans = X",
"+ans = X - a * D",
"+if (K - a) % 2:",
"+ ans = D - ans"
] | false
| 0.104981
| 0.042595
| 2.464619
|
[
"s191963267",
"s968004725"
] |
u276192130
|
p03435
|
python
|
s316600880
|
s924947039
| 19
| 17
| 3,064
| 3,064
|
Accepted
|
Accepted
| 10.53
|
c = []
for i in range(3):
c.append(list(map(int, input().split())))
tmp = [[] for i in range(4)]
for i in range(3):
tmp[0].append(c[1][i] - c[0][i])
tmp[1].append(c[2][i] - c[0][i])
tmp[2].append(c[i][1] - c[i][0])
tmp[3].append(c[i][2] - c[i][0])
if set([len(set(i)) for i in tmp]) == {1}:
print('Yes')
else:
print('No')
|
c = []
for i in range(3):
c.append(list(map(int, input().split())))
tmp = [[] for i in range(4)]
for i in range(3):
for j in range(2):
tmp[j].append(c[j+1][i] - c[0][i])
tmp[j+2].append(c[i][j+1] - c[i][0])
if set([len(set(i)) for i in tmp]) == {1}:
print('Yes')
else:
print('No')
| 13
| 12
| 362
| 324
|
c = []
for i in range(3):
c.append(list(map(int, input().split())))
tmp = [[] for i in range(4)]
for i in range(3):
tmp[0].append(c[1][i] - c[0][i])
tmp[1].append(c[2][i] - c[0][i])
tmp[2].append(c[i][1] - c[i][0])
tmp[3].append(c[i][2] - c[i][0])
if set([len(set(i)) for i in tmp]) == {1}:
print("Yes")
else:
print("No")
|
c = []
for i in range(3):
c.append(list(map(int, input().split())))
tmp = [[] for i in range(4)]
for i in range(3):
for j in range(2):
tmp[j].append(c[j + 1][i] - c[0][i])
tmp[j + 2].append(c[i][j + 1] - c[i][0])
if set([len(set(i)) for i in tmp]) == {1}:
print("Yes")
else:
print("No")
| false
| 7.692308
|
[
"- tmp[0].append(c[1][i] - c[0][i])",
"- tmp[1].append(c[2][i] - c[0][i])",
"- tmp[2].append(c[i][1] - c[i][0])",
"- tmp[3].append(c[i][2] - c[i][0])",
"+ for j in range(2):",
"+ tmp[j].append(c[j + 1][i] - c[0][i])",
"+ tmp[j + 2].append(c[i][j + 1] - c[i][0])"
] | false
| 0.057103
| 0.050462
| 1.131622
|
[
"s316600880",
"s924947039"
] |
u562935282
|
p03426
|
python
|
s067421455
|
s215972929
| 686
| 355
| 50,628
| 27,352
|
Accepted
|
Accepted
| 48.25
|
h, w, d = list(map(int, input().split()))
A = [list(map(int, input().split())) for _ in range(h)]
nc = dict()
for row in range(h):
for col in range(w):
v = A[row][col]
nc[v] = (row, col)
q = int(eval(input()))
lrs = [list(map(int, input().split())) for _ in range(q)]
c_sums = [[0] for _ in range(d)]
for r in range(d):
k = 0
if r == 0: k = 1
while r + (k + 1) * d <= h * w:
i, j = nc[r + k * d]
x, y = nc[r + (k + 1) * d]
t = c_sums[r][-1] + abs(x - i) + abs(y - j)
c_sums[r].append(t)
k += 1
for lr in lrs:
l, r = lr
ld, rest = divmod(l, d)
rd = r // d
if rest == 0:
ld -=1
rd -=1
print((c_sums[rest][rd] - c_sums[rest][ld]))
|
def main():
import sys
input = sys.stdin.readline
H, W, D = map(int, input().split())
A = [[int(x) for x in input().split()] for _ in range(H)]
B = [[] for _ in range(D)]
C = [None] * (H * W)
for r, row in enumerate(A):
for c, cell in enumerate(row):
C[cell - 1] = r, c
for x in range(H * W):
r = x % D
if B[r]:
cr, cc = C[x]
pr, pc = C[x - D]
cost = abs(cr - pr) + abs(cc - pc)
B[r].append(B[r][-1] + cost)
else:
B[r].append(0)
ans = []
Q = int(input())
for _ in range(Q):
L, R = (int(x) - 1 for x in input().split())
r = R % D
ql, qr = L // D, R // D
ans.append(B[r][qr] - B[r][ql])
print(*ans, sep='\n')
if __name__ == '__main__':
main()
| 31
| 39
| 755
| 877
|
h, w, d = list(map(int, input().split()))
A = [list(map(int, input().split())) for _ in range(h)]
nc = dict()
for row in range(h):
for col in range(w):
v = A[row][col]
nc[v] = (row, col)
q = int(eval(input()))
lrs = [list(map(int, input().split())) for _ in range(q)]
c_sums = [[0] for _ in range(d)]
for r in range(d):
k = 0
if r == 0:
k = 1
while r + (k + 1) * d <= h * w:
i, j = nc[r + k * d]
x, y = nc[r + (k + 1) * d]
t = c_sums[r][-1] + abs(x - i) + abs(y - j)
c_sums[r].append(t)
k += 1
for lr in lrs:
l, r = lr
ld, rest = divmod(l, d)
rd = r // d
if rest == 0:
ld -= 1
rd -= 1
print((c_sums[rest][rd] - c_sums[rest][ld]))
|
def main():
import sys
input = sys.stdin.readline
H, W, D = map(int, input().split())
A = [[int(x) for x in input().split()] for _ in range(H)]
B = [[] for _ in range(D)]
C = [None] * (H * W)
for r, row in enumerate(A):
for c, cell in enumerate(row):
C[cell - 1] = r, c
for x in range(H * W):
r = x % D
if B[r]:
cr, cc = C[x]
pr, pc = C[x - D]
cost = abs(cr - pr) + abs(cc - pc)
B[r].append(B[r][-1] + cost)
else:
B[r].append(0)
ans = []
Q = int(input())
for _ in range(Q):
L, R = (int(x) - 1 for x in input().split())
r = R % D
ql, qr = L // D, R // D
ans.append(B[r][qr] - B[r][ql])
print(*ans, sep="\n")
if __name__ == "__main__":
main()
| false
| 20.512821
|
[
"-h, w, d = list(map(int, input().split()))",
"-A = [list(map(int, input().split())) for _ in range(h)]",
"-nc = dict()",
"-for row in range(h):",
"- for col in range(w):",
"- v = A[row][col]",
"- nc[v] = (row, col)",
"-q = int(eval(input()))",
"-lrs = [list(map(int, input().split())) for _ in range(q)]",
"-c_sums = [[0] for _ in range(d)]",
"-for r in range(d):",
"- k = 0",
"- if r == 0:",
"- k = 1",
"- while r + (k + 1) * d <= h * w:",
"- i, j = nc[r + k * d]",
"- x, y = nc[r + (k + 1) * d]",
"- t = c_sums[r][-1] + abs(x - i) + abs(y - j)",
"- c_sums[r].append(t)",
"- k += 1",
"-for lr in lrs:",
"- l, r = lr",
"- ld, rest = divmod(l, d)",
"- rd = r // d",
"- if rest == 0:",
"- ld -= 1",
"- rd -= 1",
"- print((c_sums[rest][rd] - c_sums[rest][ld]))",
"+def main():",
"+ import sys",
"+",
"+ input = sys.stdin.readline",
"+ H, W, D = map(int, input().split())",
"+ A = [[int(x) for x in input().split()] for _ in range(H)]",
"+ B = [[] for _ in range(D)]",
"+ C = [None] * (H * W)",
"+ for r, row in enumerate(A):",
"+ for c, cell in enumerate(row):",
"+ C[cell - 1] = r, c",
"+ for x in range(H * W):",
"+ r = x % D",
"+ if B[r]:",
"+ cr, cc = C[x]",
"+ pr, pc = C[x - D]",
"+ cost = abs(cr - pr) + abs(cc - pc)",
"+ B[r].append(B[r][-1] + cost)",
"+ else:",
"+ B[r].append(0)",
"+ ans = []",
"+ Q = int(input())",
"+ for _ in range(Q):",
"+ L, R = (int(x) - 1 for x in input().split())",
"+ r = R % D",
"+ ql, qr = L // D, R // D",
"+ ans.append(B[r][qr] - B[r][ql])",
"+ print(*ans, sep=\"\\n\")",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false
| 0.042291
| 0.03669
| 1.152644
|
[
"s067421455",
"s215972929"
] |
u761529120
|
p03611
|
python
|
s857195176
|
s641276460
| 180
| 81
| 20,692
| 14,860
|
Accepted
|
Accepted
| 55
|
# 辞書を用意して最大値を取得する
N = int(eval(input()))
a = list(map(int, input().split()))
cnt = {}
for i in a:
for j in [-1,0,1]:
cnt.setdefault(i+j, 0)
cnt[i+j] += 1
print((max(cnt.values())))
|
n = int(eval(input()))
cnt = [0] * 100002
a = list(map(int, input().split()))
for v in a:
cnt[v-1] += 1
cnt[v] += 1
cnt[v+1] += 1
print((max(cnt)))
| 13
| 9
| 208
| 164
|
# 辞書を用意して最大値を取得する
N = int(eval(input()))
a = list(map(int, input().split()))
cnt = {}
for i in a:
for j in [-1, 0, 1]:
cnt.setdefault(i + j, 0)
cnt[i + j] += 1
print((max(cnt.values())))
|
n = int(eval(input()))
cnt = [0] * 100002
a = list(map(int, input().split()))
for v in a:
cnt[v - 1] += 1
cnt[v] += 1
cnt[v + 1] += 1
print((max(cnt)))
| false
| 30.769231
|
[
"-# 辞書を用意して最大値を取得する",
"-N = int(eval(input()))",
"+n = int(eval(input()))",
"+cnt = [0] * 100002",
"-cnt = {}",
"-for i in a:",
"- for j in [-1, 0, 1]:",
"- cnt.setdefault(i + j, 0)",
"- cnt[i + j] += 1",
"-print((max(cnt.values())))",
"+for v in a:",
"+ cnt[v - 1] += 1",
"+ cnt[v] += 1",
"+ cnt[v + 1] += 1",
"+print((max(cnt)))"
] | false
| 0.039861
| 0.083037
| 0.480036
|
[
"s857195176",
"s641276460"
] |
u203843959
|
p02769
|
python
|
s736696219
|
s396632549
| 449
| 365
| 181,236
| 11,052
|
Accepted
|
Accepted
| 18.71
|
import sys
sys.setrecursionlimit(10**9)
MOD=10**9+7
n,k=list(map(int,input().split()))
def pow_mod(x,n):
if n==0:
return 1
elif n==1:
return x
else:
xn2=pow_mod(x,n//2)
if n%2==0:
return (xn2*xn2)%MOD
else:
return (xn2*xn2*x)%MOD
def fact_mod(a):
if a<=1:
return 1
else:
return a*fact_mod(a-1)%MOD
def perm_mod(n,a):
if a==1:
return n
else:
return (n*perm_mod(n-1,a-1))%MOD
def inv_mod(a):
return pow_mod(a,MOD-2)%MOD
def comb_mod(na,fa):
ainv=inv_mod(fa)
return (na*ainv)%MOD
if k>=n-1:
#nHn=(2n-1)Cn
perm=perm_mod(2*n-1,n)
fact=fact_mod(n)
comb=comb_mod(perm,fact)
#print(perm,fact,comb)
print(comb)
else:
inv_table = [0]+[1]
for i in range(2,k+1):
inv_table+=[inv_table[MOD%i]*(MOD-int(MOD/i))%MOD]
comb_sum=1
fact=1
comb1=1
comb2=1
for i in range(1,k+1):
#comb1=comb1*(n-i+1)//i
comb1=(comb1*(n-i+1)*inv_table[i])%MOD
#comb2=comb2*(n-i)//i
comb2=(comb2*(n-i)*inv_table[i])%MOD
comb=(comb1*comb2)%MOD
comb_sum+=comb
print((comb_sum%MOD))
|
import sys
sys.setrecursionlimit(10**9)
MOD=10**9+7
n,k=list(map(int,input().split()))
if k>=n-1:
k=n-1
inv_table = [0]+[1]
for i in range(2,k+1):
inv_table+=[inv_table[MOD%i]*(MOD-int(MOD/i))%MOD]
comb_sum=1
fact=1
comb1=1
comb2=1
for i in range(1,k+1):
comb1=(comb1*(n-i+1)*inv_table[i])%MOD
comb2=(comb2*(n-i)*inv_table[i])%MOD
comb=(comb1*comb2)%MOD
comb_sum+=comb
print((comb_sum%MOD))
| 62
| 24
| 1,139
| 422
|
import sys
sys.setrecursionlimit(10**9)
MOD = 10**9 + 7
n, k = list(map(int, input().split()))
def pow_mod(x, n):
if n == 0:
return 1
elif n == 1:
return x
else:
xn2 = pow_mod(x, n // 2)
if n % 2 == 0:
return (xn2 * xn2) % MOD
else:
return (xn2 * xn2 * x) % MOD
def fact_mod(a):
if a <= 1:
return 1
else:
return a * fact_mod(a - 1) % MOD
def perm_mod(n, a):
if a == 1:
return n
else:
return (n * perm_mod(n - 1, a - 1)) % MOD
def inv_mod(a):
return pow_mod(a, MOD - 2) % MOD
def comb_mod(na, fa):
ainv = inv_mod(fa)
return (na * ainv) % MOD
if k >= n - 1:
# nHn=(2n-1)Cn
perm = perm_mod(2 * n - 1, n)
fact = fact_mod(n)
comb = comb_mod(perm, fact)
# print(perm,fact,comb)
print(comb)
else:
inv_table = [0] + [1]
for i in range(2, k + 1):
inv_table += [inv_table[MOD % i] * (MOD - int(MOD / i)) % MOD]
comb_sum = 1
fact = 1
comb1 = 1
comb2 = 1
for i in range(1, k + 1):
# comb1=comb1*(n-i+1)//i
comb1 = (comb1 * (n - i + 1) * inv_table[i]) % MOD
# comb2=comb2*(n-i)//i
comb2 = (comb2 * (n - i) * inv_table[i]) % MOD
comb = (comb1 * comb2) % MOD
comb_sum += comb
print((comb_sum % MOD))
|
import sys
sys.setrecursionlimit(10**9)
MOD = 10**9 + 7
n, k = list(map(int, input().split()))
if k >= n - 1:
k = n - 1
inv_table = [0] + [1]
for i in range(2, k + 1):
inv_table += [inv_table[MOD % i] * (MOD - int(MOD / i)) % MOD]
comb_sum = 1
fact = 1
comb1 = 1
comb2 = 1
for i in range(1, k + 1):
comb1 = (comb1 * (n - i + 1) * inv_table[i]) % MOD
comb2 = (comb2 * (n - i) * inv_table[i]) % MOD
comb = (comb1 * comb2) % MOD
comb_sum += comb
print((comb_sum % MOD))
| false
| 61.290323
|
[
"-",
"-",
"-def pow_mod(x, n):",
"- if n == 0:",
"- return 1",
"- elif n == 1:",
"- return x",
"- else:",
"- xn2 = pow_mod(x, n // 2)",
"- if n % 2 == 0:",
"- return (xn2 * xn2) % MOD",
"- else:",
"- return (xn2 * xn2 * x) % MOD",
"-",
"-",
"-def fact_mod(a):",
"- if a <= 1:",
"- return 1",
"- else:",
"- return a * fact_mod(a - 1) % MOD",
"-",
"-",
"-def perm_mod(n, a):",
"- if a == 1:",
"- return n",
"- else:",
"- return (n * perm_mod(n - 1, a - 1)) % MOD",
"-",
"-",
"-def inv_mod(a):",
"- return pow_mod(a, MOD - 2) % MOD",
"-",
"-",
"-def comb_mod(na, fa):",
"- ainv = inv_mod(fa)",
"- return (na * ainv) % MOD",
"-",
"-",
"- # nHn=(2n-1)Cn",
"- perm = perm_mod(2 * n - 1, n)",
"- fact = fact_mod(n)",
"- comb = comb_mod(perm, fact)",
"- # print(perm,fact,comb)",
"- print(comb)",
"-else:",
"- inv_table = [0] + [1]",
"- for i in range(2, k + 1):",
"- inv_table += [inv_table[MOD % i] * (MOD - int(MOD / i)) % MOD]",
"- comb_sum = 1",
"- fact = 1",
"- comb1 = 1",
"- comb2 = 1",
"- for i in range(1, k + 1):",
"- # comb1=comb1*(n-i+1)//i",
"- comb1 = (comb1 * (n - i + 1) * inv_table[i]) % MOD",
"- # comb2=comb2*(n-i)//i",
"- comb2 = (comb2 * (n - i) * inv_table[i]) % MOD",
"- comb = (comb1 * comb2) % MOD",
"- comb_sum += comb",
"- print((comb_sum % MOD))",
"+ k = n - 1",
"+inv_table = [0] + [1]",
"+for i in range(2, k + 1):",
"+ inv_table += [inv_table[MOD % i] * (MOD - int(MOD / i)) % MOD]",
"+comb_sum = 1",
"+fact = 1",
"+comb1 = 1",
"+comb2 = 1",
"+for i in range(1, k + 1):",
"+ comb1 = (comb1 * (n - i + 1) * inv_table[i]) % MOD",
"+ comb2 = (comb2 * (n - i) * inv_table[i]) % MOD",
"+ comb = (comb1 * comb2) % MOD",
"+ comb_sum += comb",
"+print((comb_sum % MOD))"
] | false
| 0.183478
| 0.146218
| 1.254832
|
[
"s736696219",
"s396632549"
] |
u671060652
|
p03103
|
python
|
s073601371
|
s103618331
| 799
| 302
| 90,196
| 92,508
|
Accepted
|
Accepted
| 62.2
|
import itertools
import math
import fractions
import functools
import copy
n, m = list(map(int, input().split()))
ab = []
for i in range(n):
ab.append(list(map(int, input().split())))
ab.sort(key=lambda x: x[0])
yen = 0
amount = 0
index = 0
for i in range(n):
if amount < m:
yen += ab[i][0] * ab[i][1]
amount += ab[i][1]
index = i
else: break
b = 0
for i in range(index):
b += ab[i][1]
print((yen - ab[index][1]*ab[index][0] + ab[index][0]*(m-b)))
|
def main():
# n = int(input())
n, m = list(map(int, input().split()))
# a = list(map(int, input().split()))
# s = input()
# h = [int(input()) for _ in rane(n)]
ab = []
for i in range(n):
a, b = list(map(int, input().split()))
ab.append([a, b])
cost = 0
temp_i = 0
ab.sort(key=lambda x: x[0])
for i in range(n):
cost += ab[i][0] * ab[i][1]
m -= ab[i][1]
if m <= 0:
temp_i = i
break
if m == 0:
print(cost)
elif m < 0:
cost += ab[temp_i][0] * m
print(cost)
if __name__ == '__main__':
main()
| 25
| 31
| 506
| 655
|
import itertools
import math
import fractions
import functools
import copy
n, m = list(map(int, input().split()))
ab = []
for i in range(n):
ab.append(list(map(int, input().split())))
ab.sort(key=lambda x: x[0])
yen = 0
amount = 0
index = 0
for i in range(n):
if amount < m:
yen += ab[i][0] * ab[i][1]
amount += ab[i][1]
index = i
else:
break
b = 0
for i in range(index):
b += ab[i][1]
print((yen - ab[index][1] * ab[index][0] + ab[index][0] * (m - b)))
|
def main():
# n = int(input())
n, m = list(map(int, input().split()))
# a = list(map(int, input().split()))
# s = input()
# h = [int(input()) for _ in rane(n)]
ab = []
for i in range(n):
a, b = list(map(int, input().split()))
ab.append([a, b])
cost = 0
temp_i = 0
ab.sort(key=lambda x: x[0])
for i in range(n):
cost += ab[i][0] * ab[i][1]
m -= ab[i][1]
if m <= 0:
temp_i = i
break
if m == 0:
print(cost)
elif m < 0:
cost += ab[temp_i][0] * m
print(cost)
if __name__ == "__main__":
main()
| false
| 19.354839
|
[
"-import itertools",
"-import math",
"-import fractions",
"-import functools",
"-import copy",
"+def main():",
"+ # n = int(input())",
"+ n, m = list(map(int, input().split()))",
"+ # a = list(map(int, input().split()))",
"+ # s = input()",
"+ # h = [int(input()) for _ in rane(n)]",
"+ ab = []",
"+ for i in range(n):",
"+ a, b = list(map(int, input().split()))",
"+ ab.append([a, b])",
"+ cost = 0",
"+ temp_i = 0",
"+ ab.sort(key=lambda x: x[0])",
"+ for i in range(n):",
"+ cost += ab[i][0] * ab[i][1]",
"+ m -= ab[i][1]",
"+ if m <= 0:",
"+ temp_i = i",
"+ break",
"+ if m == 0:",
"+ print(cost)",
"+ elif m < 0:",
"+ cost += ab[temp_i][0] * m",
"+ print(cost)",
"-n, m = list(map(int, input().split()))",
"-ab = []",
"-for i in range(n):",
"- ab.append(list(map(int, input().split())))",
"-ab.sort(key=lambda x: x[0])",
"-yen = 0",
"-amount = 0",
"-index = 0",
"-for i in range(n):",
"- if amount < m:",
"- yen += ab[i][0] * ab[i][1]",
"- amount += ab[i][1]",
"- index = i",
"- else:",
"- break",
"-b = 0",
"-for i in range(index):",
"- b += ab[i][1]",
"-print((yen - ab[index][1] * ab[index][0] + ab[index][0] * (m - b)))",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false
| 0.035686
| 0.036052
| 0.989838
|
[
"s073601371",
"s103618331"
] |
u761320129
|
p02839
|
python
|
s086230824
|
s162143827
| 106
| 90
| 19,700
| 9,988
|
Accepted
|
Accepted
| 15.09
|
H,W = list(map(int,input().split()))
A = [list(map(int,input().split())) for i in range(H)]
B = [list(map(int,input().split())) for i in range(H)]
C = [[abs(a-b) for a,b in zip(arow,brow)] for arow,brow in zip(A,B)]
ofs = 80*(H+W)
dp = [[0]*W for _ in range(H)]
dp[0][0] = (1<<(ofs+C[0][0])) | (1<<(ofs-C[0][0]))
for i,crow in enumerate(C):
for j,c in enumerate(crow):
if i:
dp[i][j] = (dp[i-1][j]<<c) | (dp[i-1][j]>>c)
if j:
dp[i][j] |= ((dp[i][j-1]<<c) | (dp[i][j-1]>>c))
ans = ofs*2
for i in range(ofs*2):
if dp[-1][-1]&(1<<i):
ans = min(ans, abs(i-ofs))
print(ans)
|
H,W = list(map(int,input().split()))
A = [list(map(int,input().split())) for i in range(H)]
B = [list(map(int,input().split())) for i in range(H)]
C = []
for arow,brow in zip(A,B):
C.append([abs(a-b) for a,b in zip(arow,brow)])
ofs = 80*(H+W)
dp = [0] * W
dp[0] = (1<<(ofs+C[0][0])) | (1<<(ofs-C[0][0]))
for j in range(W-1):
dp[j+1] = (dp[j] << C[0][j+1]) | (dp[j] >> C[0][j+1])
for i in range(1,H):
dp2 = [0] * W
for j in range(W):
dp2[j] = (dp[j] << C[i][j]) | (dp[j] >> C[i][j])
if j:
dp2[j] |= (dp2[j-1] << C[i][j]) | (dp2[j-1] >> C[i][j])
dp = dp2
ans = ofs*2
for i in range(ofs*2):
if dp[-1] & (1<<i):
ans = min(ans, abs(ofs - i))
print(ans)
| 20
| 26
| 639
| 729
|
H, W = list(map(int, input().split()))
A = [list(map(int, input().split())) for i in range(H)]
B = [list(map(int, input().split())) for i in range(H)]
C = [[abs(a - b) for a, b in zip(arow, brow)] for arow, brow in zip(A, B)]
ofs = 80 * (H + W)
dp = [[0] * W for _ in range(H)]
dp[0][0] = (1 << (ofs + C[0][0])) | (1 << (ofs - C[0][0]))
for i, crow in enumerate(C):
for j, c in enumerate(crow):
if i:
dp[i][j] = (dp[i - 1][j] << c) | (dp[i - 1][j] >> c)
if j:
dp[i][j] |= (dp[i][j - 1] << c) | (dp[i][j - 1] >> c)
ans = ofs * 2
for i in range(ofs * 2):
if dp[-1][-1] & (1 << i):
ans = min(ans, abs(i - ofs))
print(ans)
|
H, W = list(map(int, input().split()))
A = [list(map(int, input().split())) for i in range(H)]
B = [list(map(int, input().split())) for i in range(H)]
C = []
for arow, brow in zip(A, B):
C.append([abs(a - b) for a, b in zip(arow, brow)])
ofs = 80 * (H + W)
dp = [0] * W
dp[0] = (1 << (ofs + C[0][0])) | (1 << (ofs - C[0][0]))
for j in range(W - 1):
dp[j + 1] = (dp[j] << C[0][j + 1]) | (dp[j] >> C[0][j + 1])
for i in range(1, H):
dp2 = [0] * W
for j in range(W):
dp2[j] = (dp[j] << C[i][j]) | (dp[j] >> C[i][j])
if j:
dp2[j] |= (dp2[j - 1] << C[i][j]) | (dp2[j - 1] >> C[i][j])
dp = dp2
ans = ofs * 2
for i in range(ofs * 2):
if dp[-1] & (1 << i):
ans = min(ans, abs(ofs - i))
print(ans)
| false
| 23.076923
|
[
"-C = [[abs(a - b) for a, b in zip(arow, brow)] for arow, brow in zip(A, B)]",
"+C = []",
"+for arow, brow in zip(A, B):",
"+ C.append([abs(a - b) for a, b in zip(arow, brow)])",
"-dp = [[0] * W for _ in range(H)]",
"-dp[0][0] = (1 << (ofs + C[0][0])) | (1 << (ofs - C[0][0]))",
"-for i, crow in enumerate(C):",
"- for j, c in enumerate(crow):",
"- if i:",
"- dp[i][j] = (dp[i - 1][j] << c) | (dp[i - 1][j] >> c)",
"+dp = [0] * W",
"+dp[0] = (1 << (ofs + C[0][0])) | (1 << (ofs - C[0][0]))",
"+for j in range(W - 1):",
"+ dp[j + 1] = (dp[j] << C[0][j + 1]) | (dp[j] >> C[0][j + 1])",
"+for i in range(1, H):",
"+ dp2 = [0] * W",
"+ for j in range(W):",
"+ dp2[j] = (dp[j] << C[i][j]) | (dp[j] >> C[i][j])",
"- dp[i][j] |= (dp[i][j - 1] << c) | (dp[i][j - 1] >> c)",
"+ dp2[j] |= (dp2[j - 1] << C[i][j]) | (dp2[j - 1] >> C[i][j])",
"+ dp = dp2",
"- if dp[-1][-1] & (1 << i):",
"- ans = min(ans, abs(i - ofs))",
"+ if dp[-1] & (1 << i):",
"+ ans = min(ans, abs(ofs - i))"
] | false
| 0.042887
| 0.037278
| 1.150465
|
[
"s086230824",
"s162143827"
] |
u325282913
|
p02691
|
python
|
s343948498
|
s750117009
| 242
| 154
| 61,640
| 126,540
|
Accepted
|
Accepted
| 36.36
|
from collections import defaultdict
d = defaultdict(int)
N = int(eval(input()))
arr = list(map(int, input().split()))
ans = 0
for i in range(N):
ans += d[(i+1)-arr[i]]
d[(i+1)+arr[i]] += 1
print(ans)
|
from collections import defaultdict
N = int(eval(input()))
arr = list(map(int, input().split()))
d = defaultdict(int)
ans = 0
for i in range(N):
if i-arr[i] >= 0:
ans += d[i-arr[i]]
d[i+arr[i]] += 1
print(ans)
| 9
| 10
| 209
| 228
|
from collections import defaultdict
d = defaultdict(int)
N = int(eval(input()))
arr = list(map(int, input().split()))
ans = 0
for i in range(N):
ans += d[(i + 1) - arr[i]]
d[(i + 1) + arr[i]] += 1
print(ans)
|
from collections import defaultdict
N = int(eval(input()))
arr = list(map(int, input().split()))
d = defaultdict(int)
ans = 0
for i in range(N):
if i - arr[i] >= 0:
ans += d[i - arr[i]]
d[i + arr[i]] += 1
print(ans)
| false
| 10
|
[
"-d = defaultdict(int)",
"+d = defaultdict(int)",
"- ans += d[(i + 1) - arr[i]]",
"- d[(i + 1) + arr[i]] += 1",
"+ if i - arr[i] >= 0:",
"+ ans += d[i - arr[i]]",
"+ d[i + arr[i]] += 1"
] | false
| 0.08088
| 0.039068
| 2.070251
|
[
"s343948498",
"s750117009"
] |
u698064859
|
p03240
|
python
|
s736049090
|
s335764252
| 733
| 36
| 3,188
| 3,064
|
Accepted
|
Accepted
| 95.09
|
N = int(eval(input()))
points = [[int(s) for s in input().split()] for i in range(N)]
h_max = max(h for x, y, h in points)
for H in range(h_max, h_max + 1000):
for Cx in range(101):
for Cy in range(101):
ok = True
for x, y, h in points:
h_calc = max(H - abs(x - Cx) - abs(y - Cy), 0)
if h != h_calc:
ok = False
break
if ok:
print(('{} {} {}'.format(Cx, Cy, H)))
exit()
|
N = int(eval(input()))
points = [[int(s) for s in input().split()] for i in range(N)]
points.sort(key=lambda x: x[2], reverse=True)
for Cx in range(101):
for Cy in range(101):
kouho = set()
for xi, yi, hi in points:
if len(kouho) > 1:
break # 頂点が一意でない
if hi > 0:
"""観測点の高さが1以上なら頂点高を予測"""
kouho.add(hi + abs(xi - Cx) + abs(yi - Cy))
else:
"""観測点の高さが0なら式を満たしているかチェック"""
if list(kouho)[0] - abs(xi - Cx) - abs(yi - Cy) > 0:
kouho = set()
break
if len(kouho) == 1:
print(('{} {} {}'.format(Cx, Cy, list(kouho)[0])))
exit()
| 16
| 23
| 529
| 745
|
N = int(eval(input()))
points = [[int(s) for s in input().split()] for i in range(N)]
h_max = max(h for x, y, h in points)
for H in range(h_max, h_max + 1000):
for Cx in range(101):
for Cy in range(101):
ok = True
for x, y, h in points:
h_calc = max(H - abs(x - Cx) - abs(y - Cy), 0)
if h != h_calc:
ok = False
break
if ok:
print(("{} {} {}".format(Cx, Cy, H)))
exit()
|
N = int(eval(input()))
points = [[int(s) for s in input().split()] for i in range(N)]
points.sort(key=lambda x: x[2], reverse=True)
for Cx in range(101):
for Cy in range(101):
kouho = set()
for xi, yi, hi in points:
if len(kouho) > 1:
break # 頂点が一意でない
if hi > 0:
"""観測点の高さが1以上なら頂点高を予測"""
kouho.add(hi + abs(xi - Cx) + abs(yi - Cy))
else:
"""観測点の高さが0なら式を満たしているかチェック"""
if list(kouho)[0] - abs(xi - Cx) - abs(yi - Cy) > 0:
kouho = set()
break
if len(kouho) == 1:
print(("{} {} {}".format(Cx, Cy, list(kouho)[0])))
exit()
| false
| 30.434783
|
[
"-h_max = max(h for x, y, h in points)",
"-for H in range(h_max, h_max + 1000):",
"- for Cx in range(101):",
"- for Cy in range(101):",
"- ok = True",
"- for x, y, h in points:",
"- h_calc = max(H - abs(x - Cx) - abs(y - Cy), 0)",
"- if h != h_calc:",
"- ok = False",
"+points.sort(key=lambda x: x[2], reverse=True)",
"+for Cx in range(101):",
"+ for Cy in range(101):",
"+ kouho = set()",
"+ for xi, yi, hi in points:",
"+ if len(kouho) > 1:",
"+ break # 頂点が一意でない",
"+ if hi > 0:",
"+ \"\"\"観測点の高さが1以上なら頂点高を予測\"\"\"",
"+ kouho.add(hi + abs(xi - Cx) + abs(yi - Cy))",
"+ else:",
"+ \"\"\"観測点の高さが0なら式を満たしているかチェック\"\"\"",
"+ if list(kouho)[0] - abs(xi - Cx) - abs(yi - Cy) > 0:",
"+ kouho = set()",
"- if ok:",
"- print((\"{} {} {}\".format(Cx, Cy, H)))",
"- exit()",
"+ if len(kouho) == 1:",
"+ print((\"{} {} {}\".format(Cx, Cy, list(kouho)[0])))",
"+ exit()"
] | false
| 0.412043
| 0.038738
| 10.636548
|
[
"s736049090",
"s335764252"
] |
u077291787
|
p02892
|
python
|
s664903330
|
s125722113
| 193
| 156
| 3,700
| 3,692
|
Accepted
|
Accepted
| 19.17
|
# AGC039B - Graph Partition
from collections import deque
def is_bipartite() -> bool:
stack = deque([(1, 1)])
color = [-1] * (N + 1)
color[1] = 1
while stack:
v, cur_color = stack.pop()
next_color = cur_color ^ 1
for u in E[v]:
if color[u] == cur_color:
return False
if color[u] == -1:
color[u] = next_color
stack.append((u, next_color))
return True
def bfs(start) -> int:
que = deque([start])
dist = [-1] * (N + 1) # dist[i] := distance from V_start to V_i
dist[start] = 0
while que:
v = que.popleft()
cur = dist[v]
for u in E[v]:
if dist[u] == -1:
dist[u] = cur + 1
que.append(u)
return max(dist)
def main():
# if bipartite graph -> diameter of the graph + 1
global N, E
N, *S = open(0).read().split()
N = int(N)
E = [0] + [[i for i, flg in enumerate(s, 1) if flg == "1"] for s in S]
if is_bipartite():
ans = max(bfs(i) for i in range(1, N + 1)) + 1
print(ans)
else:
print((-1))
if __name__ == "__main__":
main()
|
# AGC039B - Graph Partition
from collections import deque
def is_bipartite() -> bool:
stack = [(1, 1)]
color = [-1] * (N + 1)
color[1] = 1
while stack:
v, cur_color = stack.pop()
next_color = cur_color ^ 1
for u in E[v]:
if color[u] == cur_color:
return False
if color[u] == -1:
color[u] = next_color
stack.append((u, next_color))
return True
def bfs(start) -> int:
que = deque([start])
dist = [0] * (N + 1) # dist[i] := distance from V_start to V_i
dist[start] = 1
while que:
v = que.popleft()
cur = dist[v]
for u in E[v]:
if not dist[u]:
dist[u] = cur + 1
que.append(u)
return max(dist)
def main():
# if bipartite graph -> diameter of the graph + 1
global N, E
N, *S = open(0).read().split()
N = int(N)
E = [0] + [[i for i, flg in enumerate(s, 1) if flg == "1"] for s in S]
if is_bipartite():
ans = max(bfs(i) for i in range(1, N + 1))
print(ans)
else:
print((-1))
if __name__ == "__main__":
main()
| 49
| 49
| 1,229
| 1,215
|
# AGC039B - Graph Partition
from collections import deque
def is_bipartite() -> bool:
stack = deque([(1, 1)])
color = [-1] * (N + 1)
color[1] = 1
while stack:
v, cur_color = stack.pop()
next_color = cur_color ^ 1
for u in E[v]:
if color[u] == cur_color:
return False
if color[u] == -1:
color[u] = next_color
stack.append((u, next_color))
return True
def bfs(start) -> int:
que = deque([start])
dist = [-1] * (N + 1) # dist[i] := distance from V_start to V_i
dist[start] = 0
while que:
v = que.popleft()
cur = dist[v]
for u in E[v]:
if dist[u] == -1:
dist[u] = cur + 1
que.append(u)
return max(dist)
def main():
# if bipartite graph -> diameter of the graph + 1
global N, E
N, *S = open(0).read().split()
N = int(N)
E = [0] + [[i for i, flg in enumerate(s, 1) if flg == "1"] for s in S]
if is_bipartite():
ans = max(bfs(i) for i in range(1, N + 1)) + 1
print(ans)
else:
print((-1))
if __name__ == "__main__":
main()
|
# AGC039B - Graph Partition
from collections import deque
def is_bipartite() -> bool:
stack = [(1, 1)]
color = [-1] * (N + 1)
color[1] = 1
while stack:
v, cur_color = stack.pop()
next_color = cur_color ^ 1
for u in E[v]:
if color[u] == cur_color:
return False
if color[u] == -1:
color[u] = next_color
stack.append((u, next_color))
return True
def bfs(start) -> int:
que = deque([start])
dist = [0] * (N + 1) # dist[i] := distance from V_start to V_i
dist[start] = 1
while que:
v = que.popleft()
cur = dist[v]
for u in E[v]:
if not dist[u]:
dist[u] = cur + 1
que.append(u)
return max(dist)
def main():
# if bipartite graph -> diameter of the graph + 1
global N, E
N, *S = open(0).read().split()
N = int(N)
E = [0] + [[i for i, flg in enumerate(s, 1) if flg == "1"] for s in S]
if is_bipartite():
ans = max(bfs(i) for i in range(1, N + 1))
print(ans)
else:
print((-1))
if __name__ == "__main__":
main()
| false
| 0
|
[
"- stack = deque([(1, 1)])",
"+ stack = [(1, 1)]",
"- dist = [-1] * (N + 1) # dist[i] := distance from V_start to V_i",
"- dist[start] = 0",
"+ dist = [0] * (N + 1) # dist[i] := distance from V_start to V_i",
"+ dist[start] = 1",
"- if dist[u] == -1:",
"+ if not dist[u]:",
"- ans = max(bfs(i) for i in range(1, N + 1)) + 1",
"+ ans = max(bfs(i) for i in range(1, N + 1))"
] | false
| 0.072532
| 0.034673
| 2.09189
|
[
"s664903330",
"s125722113"
] |
u713492631
|
p02639
|
python
|
s230641077
|
s936062520
| 28
| 24
| 8,940
| 9,028
|
Accepted
|
Accepted
| 14.29
|
print((list(map(int, input().split())).index(0) + 1))
|
print((int(input().split().index("0"))+1))
| 1
| 1
| 51
| 40
|
print((list(map(int, input().split())).index(0) + 1))
|
print((int(input().split().index("0")) + 1))
| false
| 0
|
[
"-print((list(map(int, input().split())).index(0) + 1))",
"+print((int(input().split().index(\"0\")) + 1))"
] | false
| 0.047834
| 0.040829
| 1.171559
|
[
"s230641077",
"s936062520"
] |
u945181840
|
p03821
|
python
|
s812751568
|
s334220653
| 218
| 180
| 10,996
| 10,868
|
Accepted
|
Accepted
| 17.43
|
import sys
input = sys.stdin.readline
N = int(eval(input()))
A = [0] * N
B = [0] * N
for i in range(N):
A[i], B[i] = list(map(int, input().split()))
ans = 0
for i in reversed(list(range(N))):
if (ans + A[i]) % B[i] != 0:
ans += ((ans + A[i]) // B[i] + 1) * B[i] - (ans + A[i])
print(ans)
|
import sys
input = sys.stdin.readline
N = int(eval(input()))
A = [0] * N
B = [0] * N
for i in range(N):
A[i], B[i] = list(map(int, input().split()))
ans = 0
for i in reversed(list(range(N))):
t = (ans + A[i]) % B[i]
if t != 0:
ans += B[i] - t
print(ans)
| 17
| 18
| 306
| 277
|
import sys
input = sys.stdin.readline
N = int(eval(input()))
A = [0] * N
B = [0] * N
for i in range(N):
A[i], B[i] = list(map(int, input().split()))
ans = 0
for i in reversed(list(range(N))):
if (ans + A[i]) % B[i] != 0:
ans += ((ans + A[i]) // B[i] + 1) * B[i] - (ans + A[i])
print(ans)
|
import sys
input = sys.stdin.readline
N = int(eval(input()))
A = [0] * N
B = [0] * N
for i in range(N):
A[i], B[i] = list(map(int, input().split()))
ans = 0
for i in reversed(list(range(N))):
t = (ans + A[i]) % B[i]
if t != 0:
ans += B[i] - t
print(ans)
| false
| 5.555556
|
[
"- if (ans + A[i]) % B[i] != 0:",
"- ans += ((ans + A[i]) // B[i] + 1) * B[i] - (ans + A[i])",
"+ t = (ans + A[i]) % B[i]",
"+ if t != 0:",
"+ ans += B[i] - t"
] | false
| 0.092451
| 0.0461
| 2.005459
|
[
"s812751568",
"s334220653"
] |
u562935282
|
p02621
|
python
|
s189223753
|
s312738897
| 29
| 21
| 8,916
| 8,892
|
Accepted
|
Accepted
| 27.59
|
def main():
a = int(eval(input()))
ret = a
ret += a * a
ret += a * a * a
print(ret)
if __name__ == '__main__':
main()
|
def main():
N = int(eval(input()))
print((N + N * N + N * N * N))
if __name__ == '__main__':
main()
# import sys
# input = sys.stdin.readline
#
# sys.setrecursionlimit(10 ** 7)
#
# (int(x)-1 for x in input().split())
# rstrip()
#
# def binary_search(*, ok, ng, func):
# while abs(ok - ng) > 1:
# mid = (ok + ng) // 2
# if func(mid):
# ok = mid
# else:
# ng = mid
# return ok
| 10
| 24
| 147
| 463
|
def main():
a = int(eval(input()))
ret = a
ret += a * a
ret += a * a * a
print(ret)
if __name__ == "__main__":
main()
|
def main():
N = int(eval(input()))
print((N + N * N + N * N * N))
if __name__ == "__main__":
main()
# import sys
# input = sys.stdin.readline
#
# sys.setrecursionlimit(10 ** 7)
#
# (int(x)-1 for x in input().split())
# rstrip()
#
# def binary_search(*, ok, ng, func):
# while abs(ok - ng) > 1:
# mid = (ok + ng) // 2
# if func(mid):
# ok = mid
# else:
# ng = mid
# return ok
| false
| 58.333333
|
[
"- a = int(eval(input()))",
"- ret = a",
"- ret += a * a",
"- ret += a * a * a",
"- print(ret)",
"+ N = int(eval(input()))",
"+ print((N + N * N + N * N * N))",
"+# import sys",
"+# input = sys.stdin.readline",
"+#",
"+# sys.setrecursionlimit(10 ** 7)",
"+#",
"+# (int(x)-1 for x in input().split())",
"+# rstrip()",
"+#",
"+# def binary_search(*, ok, ng, func):",
"+# while abs(ok - ng) > 1:",
"+# mid = (ok + ng) // 2",
"+# if func(mid):",
"+# ok = mid",
"+# else:",
"+# ng = mid",
"+# return ok"
] | false
| 0.070297
| 0.043295
| 1.623669
|
[
"s189223753",
"s312738897"
] |
u223646582
|
p03240
|
python
|
s160710870
|
s545771820
| 1,167
| 553
| 3,064
| 3,064
|
Accepted
|
Accepted
| 52.61
|
N=int(eval(input()))
xyh=[list(map(int,input().split())) for _ in range(N)]
for Cx in range(101): # x
for Cy in range(101): # y
flg=True
k=0
while xyh[k][2]+abs(xyh[k][0]-Cx)+abs(xyh[k][1]-Cy) <1 or xyh[k][2]<1:
k+=1
H=xyh[k][2]+abs(xyh[k][0]-Cx)+abs(xyh[k][1]-Cy)
for i in range(len(xyh)):
if max(H-abs(xyh[i][0]-Cx)-abs(xyh[i][1]-Cy),0)!=xyh[i][2]:
flg=False
if flg:
print((Cx,Cy,H))
exit()
|
N = int(eval(input()))
XYH = []
for _ in range(N):
x, y, h = list(map(int, input().split()))
XYH.append((x, y, h))
XYH.sort(key=lambda x: -x[2])
for Cx in range(0, 101):
for Cy in range(0, 101):
flg = True
if XYH[0][2] == 0:
Ch = 1
else:
Ch = XYH[0][2]+abs(XYH[0][0]-Cx)+abs(XYH[0][1]-Cy)
for x, y, h in XYH:
if h != max(Ch - abs(x-Cx) - abs(y-Cy), 0):
flg = False
if flg:
print((Cx, Cy, Ch))
exit()
| 16
| 24
| 526
| 542
|
N = int(eval(input()))
xyh = [list(map(int, input().split())) for _ in range(N)]
for Cx in range(101): # x
for Cy in range(101): # y
flg = True
k = 0
while (
xyh[k][2] + abs(xyh[k][0] - Cx) + abs(xyh[k][1] - Cy) < 1 or xyh[k][2] < 1
):
k += 1
H = xyh[k][2] + abs(xyh[k][0] - Cx) + abs(xyh[k][1] - Cy)
for i in range(len(xyh)):
if max(H - abs(xyh[i][0] - Cx) - abs(xyh[i][1] - Cy), 0) != xyh[i][2]:
flg = False
if flg:
print((Cx, Cy, H))
exit()
|
N = int(eval(input()))
XYH = []
for _ in range(N):
x, y, h = list(map(int, input().split()))
XYH.append((x, y, h))
XYH.sort(key=lambda x: -x[2])
for Cx in range(0, 101):
for Cy in range(0, 101):
flg = True
if XYH[0][2] == 0:
Ch = 1
else:
Ch = XYH[0][2] + abs(XYH[0][0] - Cx) + abs(XYH[0][1] - Cy)
for x, y, h in XYH:
if h != max(Ch - abs(x - Cx) - abs(y - Cy), 0):
flg = False
if flg:
print((Cx, Cy, Ch))
exit()
| false
| 33.333333
|
[
"-xyh = [list(map(int, input().split())) for _ in range(N)]",
"-for Cx in range(101): # x",
"- for Cy in range(101): # y",
"+XYH = []",
"+for _ in range(N):",
"+ x, y, h = list(map(int, input().split()))",
"+ XYH.append((x, y, h))",
"+XYH.sort(key=lambda x: -x[2])",
"+for Cx in range(0, 101):",
"+ for Cy in range(0, 101):",
"- k = 0",
"- while (",
"- xyh[k][2] + abs(xyh[k][0] - Cx) + abs(xyh[k][1] - Cy) < 1 or xyh[k][2] < 1",
"- ):",
"- k += 1",
"- H = xyh[k][2] + abs(xyh[k][0] - Cx) + abs(xyh[k][1] - Cy)",
"- for i in range(len(xyh)):",
"- if max(H - abs(xyh[i][0] - Cx) - abs(xyh[i][1] - Cy), 0) != xyh[i][2]:",
"+ if XYH[0][2] == 0:",
"+ Ch = 1",
"+ else:",
"+ Ch = XYH[0][2] + abs(XYH[0][0] - Cx) + abs(XYH[0][1] - Cy)",
"+ for x, y, h in XYH:",
"+ if h != max(Ch - abs(x - Cx) - abs(y - Cy), 0):",
"- print((Cx, Cy, H))",
"+ print((Cx, Cy, Ch))"
] | false
| 0.058578
| 0.04785
| 1.224221
|
[
"s160710870",
"s545771820"
] |
u923279197
|
p02814
|
python
|
s240911255
|
s822873698
| 434
| 224
| 89,580
| 16,308
|
Accepted
|
Accepted
| 48.39
|
import fractions
from functools import reduce
def lcm_base(x, y):
return (x * y) // fractions.gcd(x, y)
def lcm(*numbers):
return reduce(lcm_base, numbers, 1)#数列に対しての最小公倍数
n,m = list(map(int,input().split()))
a = list(map(int,input().split()))
b = [x//2 for x in a]
c = 0
while True:
if a[0]%2:
for i in range(n):
if a[i]%2 == 0:
print((0))
exit()
break
else:
for i in range(n):
if a[i]%2:
print((0))
exit()
a[i]//=2
c += 1
least = lcm(*b)
ans = ((m//least)+1)//2
print(ans)
|
import fractions
from functools import reduce
def lcm_base(x, y):
return (x * y) // fractions.gcd(x, y)
def lcm(*numbers):
return reduce(lcm_base, numbers, 1) # 数列に対しての最小公倍数
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
b = [x // 2 for x in a]
c = 0
while a[0] % (2 ** (c + 1)) == 0:
c += 1
for x in a:
if x % (2 ** c) != 0 or x % (2 ** (c + 1)) == 0:
print((0))
exit()
lc = lcm(*b)
ans = ((m // lc) + 1) // 2
print(ans)
| 30
| 28
| 644
| 511
|
import fractions
from functools import reduce
def lcm_base(x, y):
return (x * y) // fractions.gcd(x, y)
def lcm(*numbers):
return reduce(lcm_base, numbers, 1) # 数列に対しての最小公倍数
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
b = [x // 2 for x in a]
c = 0
while True:
if a[0] % 2:
for i in range(n):
if a[i] % 2 == 0:
print((0))
exit()
break
else:
for i in range(n):
if a[i] % 2:
print((0))
exit()
a[i] //= 2
c += 1
least = lcm(*b)
ans = ((m // least) + 1) // 2
print(ans)
|
import fractions
from functools import reduce
def lcm_base(x, y):
return (x * y) // fractions.gcd(x, y)
def lcm(*numbers):
return reduce(lcm_base, numbers, 1) # 数列に対しての最小公倍数
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
b = [x // 2 for x in a]
c = 0
while a[0] % (2 ** (c + 1)) == 0:
c += 1
for x in a:
if x % (2**c) != 0 or x % (2 ** (c + 1)) == 0:
print((0))
exit()
lc = lcm(*b)
ans = ((m // lc) + 1) // 2
print(ans)
| false
| 6.666667
|
[
"-while True:",
"- if a[0] % 2:",
"- for i in range(n):",
"- if a[i] % 2 == 0:",
"- print((0))",
"- exit()",
"- break",
"- else:",
"- for i in range(n):",
"- if a[i] % 2:",
"- print((0))",
"- exit()",
"- a[i] //= 2",
"- c += 1",
"-least = lcm(*b)",
"-ans = ((m // least) + 1) // 2",
"+while a[0] % (2 ** (c + 1)) == 0:",
"+ c += 1",
"+for x in a:",
"+ if x % (2**c) != 0 or x % (2 ** (c + 1)) == 0:",
"+ print((0))",
"+ exit()",
"+lc = lcm(*b)",
"+ans = ((m // lc) + 1) // 2"
] | false
| 0.070025
| 0.075782
| 0.924036
|
[
"s240911255",
"s822873698"
] |
u018679195
|
p03457
|
python
|
s500824474
|
s144462816
| 427
| 326
| 11,736
| 5,764
|
Accepted
|
Accepted
| 23.65
|
N = int(eval(input()))
ts = [0]
xs = [0]
ys = [0]
for _ in range(N):
t,x,y = [ int(a) for a in input().split() ]
ts.append(t)
xs.append(x)
ys.append(y)
good = True
for i in range(N):
dist = abs(xs[i]-xs[i+1])+abs(ys[i]-ys[i+1])
time = ts[i+1]-ts[i]
# Parity
if dist%2 != time%2:
good = False
# Distance
if dist > time:
good = False
if good:
print('Yes')
else:
print('No')
|
n = int(input())
x = 0
y = 0
t = 0
do = True
for i in range(0, n):
z = input().split(" ")
nt = int(z[0])
nx = int(z[1])
ny = int(z[2])
dt = nt - t
dx = nx - x
dy = ny - y
t = nt
x = nx
y = ny
if (abs(dx)+abs(dy))%2 != (dt)%2:
do = False
break
if abs(dx)+abs(dy) > abs(dt):
do = False
break
if do:
print("Yes")
else:
print("No")
| 29
| 28
| 465
| 386
|
N = int(eval(input()))
ts = [0]
xs = [0]
ys = [0]
for _ in range(N):
t, x, y = [int(a) for a in input().split()]
ts.append(t)
xs.append(x)
ys.append(y)
good = True
for i in range(N):
dist = abs(xs[i] - xs[i + 1]) + abs(ys[i] - ys[i + 1])
time = ts[i + 1] - ts[i]
# Parity
if dist % 2 != time % 2:
good = False
# Distance
if dist > time:
good = False
if good:
print("Yes")
else:
print("No")
|
n = int(input())
x = 0
y = 0
t = 0
do = True
for i in range(0, n):
z = input().split(" ")
nt = int(z[0])
nx = int(z[1])
ny = int(z[2])
dt = nt - t
dx = nx - x
dy = ny - y
t = nt
x = nx
y = ny
if (abs(dx) + abs(dy)) % 2 != (dt) % 2:
do = False
break
if abs(dx) + abs(dy) > abs(dt):
do = False
break
if do:
print("Yes")
else:
print("No")
| false
| 3.448276
|
[
"-N = int(eval(input()))",
"-ts = [0]",
"-xs = [0]",
"-ys = [0]",
"-for _ in range(N):",
"- t, x, y = [int(a) for a in input().split()]",
"- ts.append(t)",
"- xs.append(x)",
"- ys.append(y)",
"-good = True",
"-for i in range(N):",
"- dist = abs(xs[i] - xs[i + 1]) + abs(ys[i] - ys[i + 1])",
"- time = ts[i + 1] - ts[i]",
"- # Parity",
"- if dist % 2 != time % 2:",
"- good = False",
"- # Distance",
"- if dist > time:",
"- good = False",
"-if good:",
"+n = int(input())",
"+x = 0",
"+y = 0",
"+t = 0",
"+do = True",
"+for i in range(0, n):",
"+ z = input().split(\" \")",
"+ nt = int(z[0])",
"+ nx = int(z[1])",
"+ ny = int(z[2])",
"+ dt = nt - t",
"+ dx = nx - x",
"+ dy = ny - y",
"+ t = nt",
"+ x = nx",
"+ y = ny",
"+ if (abs(dx) + abs(dy)) % 2 != (dt) % 2:",
"+ do = False",
"+ break",
"+ if abs(dx) + abs(dy) > abs(dt):",
"+ do = False",
"+ break",
"+if do:"
] | false
| 0.084477
| 0.121216
| 0.69691
|
[
"s500824474",
"s144462816"
] |
u767797498
|
p02596
|
python
|
s614204596
|
s336132078
| 482
| 186
| 77,800
| 8,932
|
Accepted
|
Accepted
| 61.41
|
k=int(eval(input()))
n=7%k
s=set()
i=1
while n not in s:
if n == 0:
print(i)
exit()
s.add(n)
n=(10*n+7) %k
i+=1
print((-1))
|
# Cyclic mod calculation renshuu
# kの倍数 -> N % k == 0 を探索する
# N%k の値は高々 k種類となる。k回のループで十分に網羅できる。
# kは10**6。制約上も問題がない。
k=int(eval(input()))
n=7%k
for i in range(1,k+1):
if n==0:
print(i)
exit()
# 計算量を抑えてmodするため、漸化式のような実装にすることがミソ。
n=(n*10+7)%k
print((-1))
| 12
| 15
| 142
| 276
|
k = int(eval(input()))
n = 7 % k
s = set()
i = 1
while n not in s:
if n == 0:
print(i)
exit()
s.add(n)
n = (10 * n + 7) % k
i += 1
print((-1))
|
# Cyclic mod calculation renshuu
# kの倍数 -> N % k == 0 を探索する
# N%k の値は高々 k種類となる。k回のループで十分に網羅できる。
# kは10**6。制約上も問題がない。
k = int(eval(input()))
n = 7 % k
for i in range(1, k + 1):
if n == 0:
print(i)
exit()
# 計算量を抑えてmodするため、漸化式のような実装にすることがミソ。
n = (n * 10 + 7) % k
print((-1))
| false
| 20
|
[
"+# Cyclic mod calculation renshuu",
"+# kの倍数 -> N % k == 0 を探索する",
"+# N%k の値は高々 k種類となる。k回のループで十分に網羅できる。",
"+# kは10**6。制約上も問題がない。",
"-s = set()",
"-i = 1",
"-while n not in s:",
"+for i in range(1, k + 1):",
"- s.add(n)",
"- n = (10 * n + 7) % k",
"- i += 1",
"+ # 計算量を抑えてmodするため、漸化式のような実装にすることがミソ。",
"+ n = (n * 10 + 7) % k"
] | false
| 0.181717
| 0.069376
| 2.619308
|
[
"s614204596",
"s336132078"
] |
u537782349
|
p03147
|
python
|
s561279712
|
s875319199
| 89
| 24
| 3,064
| 3,064
|
Accepted
|
Accepted
| 73.03
|
a = int(eval(input()))
b = list(map(int, input().split()))
b.insert(0, 0)
b.insert(len(b), 0)
f = 0
while True:
s = -1
e = -1
for i in range(len(b)):
if b[i] != 0 and s == -1:
s = i
elif b[i] == 0 and s != -1 and b[i-1] == 0:
s = i
elif b[i] == 0 and s != -1:
e = i
break
if s != -1 and e != -1:
f += 1
for i in range(s, e):
b[i] -= 1
elif s == -1 and e == -1:
print(f)
exit()
|
a = int(eval(input()))
b = list(map(int, input().split()))
b.insert(0, 0)
b.append(0)
d = 0
while True:
for i in range(1, len(b)):
if b[i] != 0 and b[i-1] == 0:
for j in range(i, len(b)):
if b[j] == 0 and b[j-1] != 0:
d += 1
for k in range(i, j):
b[k] -= 1
break
if sum(b) == 0:
break
print(d)
| 24
| 17
| 530
| 440
|
a = int(eval(input()))
b = list(map(int, input().split()))
b.insert(0, 0)
b.insert(len(b), 0)
f = 0
while True:
s = -1
e = -1
for i in range(len(b)):
if b[i] != 0 and s == -1:
s = i
elif b[i] == 0 and s != -1 and b[i - 1] == 0:
s = i
elif b[i] == 0 and s != -1:
e = i
break
if s != -1 and e != -1:
f += 1
for i in range(s, e):
b[i] -= 1
elif s == -1 and e == -1:
print(f)
exit()
|
a = int(eval(input()))
b = list(map(int, input().split()))
b.insert(0, 0)
b.append(0)
d = 0
while True:
for i in range(1, len(b)):
if b[i] != 0 and b[i - 1] == 0:
for j in range(i, len(b)):
if b[j] == 0 and b[j - 1] != 0:
d += 1
for k in range(i, j):
b[k] -= 1
break
if sum(b) == 0:
break
print(d)
| false
| 29.166667
|
[
"-b.insert(len(b), 0)",
"-f = 0",
"+b.append(0)",
"+d = 0",
"- s = -1",
"- e = -1",
"- for i in range(len(b)):",
"- if b[i] != 0 and s == -1:",
"- s = i",
"- elif b[i] == 0 and s != -1 and b[i - 1] == 0:",
"- s = i",
"- elif b[i] == 0 and s != -1:",
"- e = i",
"- break",
"- if s != -1 and e != -1:",
"- f += 1",
"- for i in range(s, e):",
"- b[i] -= 1",
"- elif s == -1 and e == -1:",
"- print(f)",
"- exit()",
"+ for i in range(1, len(b)):",
"+ if b[i] != 0 and b[i - 1] == 0:",
"+ for j in range(i, len(b)):",
"+ if b[j] == 0 and b[j - 1] != 0:",
"+ d += 1",
"+ for k in range(i, j):",
"+ b[k] -= 1",
"+ break",
"+ if sum(b) == 0:",
"+ break",
"+print(d)"
] | false
| 0.037187
| 0.036594
| 1.016193
|
[
"s561279712",
"s875319199"
] |
u422104747
|
p03209
|
python
|
s433043395
|
s651322144
| 194
| 176
| 38,256
| 38,384
|
Accepted
|
Accepted
| 9.28
|
def do(level,x):
if x<=0:
return 0
elif x>=j[level]:
return k[level]
res=0
x-=1
if x>=j[level-1]+1:
x-=j[level-1]+1
res+=k[level-1]+1
return res+do(level-1,x)
n,x=list(map(int,input().split()))
j=[1]+[0]*50
k=[1]+[0]*50
for i in range(1,n+1):
j[i]=j[i-1]*2+3
k[i]=k[i-1]*2+1
res=0
print((do(n,x)))
|
def do(level,x):
if x<=0: #1層も手を付けないとき
return 0
elif x>=whole[level]: #完食できるとき
return patty[level]
#それ以外、途中まで食べるときはlevel>=1の場合のみあり得る
x-=1 #このとき1層目は必ずバンズ
res=0 #食べたパティの総数を記録する
if x>=whole[level-1]+1: #真ん中のパティまで到達できるとき
x-=whole[level-1]+1
res+=patty[level-1]+1
return res+do(level-1,x)
n,x=list(map(int,input().split()))
whole=[1]+[0]*50
patty=[1]+[0]*50
for i in range(1,n+1):
whole[i]=whole[i-1]*2+3
patty[i]=patty[i-1]*2+1
res=0
print((do(n,x)))
| 20
| 21
| 373
| 528
|
def do(level, x):
if x <= 0:
return 0
elif x >= j[level]:
return k[level]
res = 0
x -= 1
if x >= j[level - 1] + 1:
x -= j[level - 1] + 1
res += k[level - 1] + 1
return res + do(level - 1, x)
n, x = list(map(int, input().split()))
j = [1] + [0] * 50
k = [1] + [0] * 50
for i in range(1, n + 1):
j[i] = j[i - 1] * 2 + 3
k[i] = k[i - 1] * 2 + 1
res = 0
print((do(n, x)))
|
def do(level, x):
if x <= 0: # 1層も手を付けないとき
return 0
elif x >= whole[level]: # 完食できるとき
return patty[level]
# それ以外、途中まで食べるときはlevel>=1の場合のみあり得る
x -= 1 # このとき1層目は必ずバンズ
res = 0 # 食べたパティの総数を記録する
if x >= whole[level - 1] + 1: # 真ん中のパティまで到達できるとき
x -= whole[level - 1] + 1
res += patty[level - 1] + 1
return res + do(level - 1, x)
n, x = list(map(int, input().split()))
whole = [1] + [0] * 50
patty = [1] + [0] * 50
for i in range(1, n + 1):
whole[i] = whole[i - 1] * 2 + 3
patty[i] = patty[i - 1] * 2 + 1
res = 0
print((do(n, x)))
| false
| 4.761905
|
[
"- if x <= 0:",
"+ if x <= 0: # 1層も手を付けないとき",
"- elif x >= j[level]:",
"- return k[level]",
"- res = 0",
"- x -= 1",
"- if x >= j[level - 1] + 1:",
"- x -= j[level - 1] + 1",
"- res += k[level - 1] + 1",
"+ elif x >= whole[level]: # 完食できるとき",
"+ return patty[level]",
"+ # それ以外、途中まで食べるときはlevel>=1の場合のみあり得る",
"+ x -= 1 # このとき1層目は必ずバンズ",
"+ res = 0 # 食べたパティの総数を記録する",
"+ if x >= whole[level - 1] + 1: # 真ん中のパティまで到達できるとき",
"+ x -= whole[level - 1] + 1",
"+ res += patty[level - 1] + 1",
"-j = [1] + [0] * 50",
"-k = [1] + [0] * 50",
"+whole = [1] + [0] * 50",
"+patty = [1] + [0] * 50",
"- j[i] = j[i - 1] * 2 + 3",
"- k[i] = k[i - 1] * 2 + 1",
"+ whole[i] = whole[i - 1] * 2 + 3",
"+ patty[i] = patty[i - 1] * 2 + 1"
] | false
| 0.051289
| 0.036614
| 1.4008
|
[
"s433043395",
"s651322144"
] |
u418826171
|
p02675
|
python
|
s540598321
|
s840531214
| 28
| 25
| 9,004
| 9,068
|
Accepted
|
Accepted
| 10.71
|
N = eval(input())
if N[-1] == '3':
print('bon')
elif N[-1] == '0' or N[-1] == '1' or N[-1] == '6' or N[-1] == '8':
print('pon')
else:
print('hon')
|
n = int(input()[-1])
if n in [3]:
print('bon')
elif n in [0,1,6,8]:
print('pon')
else:
print('hon')
| 7
| 7
| 158
| 118
|
N = eval(input())
if N[-1] == "3":
print("bon")
elif N[-1] == "0" or N[-1] == "1" or N[-1] == "6" or N[-1] == "8":
print("pon")
else:
print("hon")
|
n = int(input()[-1])
if n in [3]:
print("bon")
elif n in [0, 1, 6, 8]:
print("pon")
else:
print("hon")
| false
| 0
|
[
"-N = eval(input())",
"-if N[-1] == \"3\":",
"+n = int(input()[-1])",
"+if n in [3]:",
"-elif N[-1] == \"0\" or N[-1] == \"1\" or N[-1] == \"6\" or N[-1] == \"8\":",
"+elif n in [0, 1, 6, 8]:"
] | false
| 0.036703
| 0.094893
| 0.386788
|
[
"s540598321",
"s840531214"
] |
u562016607
|
p03607
|
python
|
s768179386
|
s478182707
| 248
| 221
| 14,700
| 15,076
|
Accepted
|
Accepted
| 10.89
|
N = int(eval(input()))
S = set([])
for i in range(N):
st = eval(input())
if set([st]) <= S:
S -= set([st])
else:
S.add(st)
print((len(S)))
|
N=int(eval(input()))
D=dict()
for i in range(N):
a=int(eval(input()))
if a in D:
D[a]+=1
else:
D[a]=1
ans=0
for i in D:
if D[i]%2==1:
ans+=1
print(ans)
| 10
| 14
| 163
| 194
|
N = int(eval(input()))
S = set([])
for i in range(N):
st = eval(input())
if set([st]) <= S:
S -= set([st])
else:
S.add(st)
print((len(S)))
|
N = int(eval(input()))
D = dict()
for i in range(N):
a = int(eval(input()))
if a in D:
D[a] += 1
else:
D[a] = 1
ans = 0
for i in D:
if D[i] % 2 == 1:
ans += 1
print(ans)
| false
| 28.571429
|
[
"-S = set([])",
"+D = dict()",
"- st = eval(input())",
"- if set([st]) <= S:",
"- S -= set([st])",
"+ a = int(eval(input()))",
"+ if a in D:",
"+ D[a] += 1",
"- S.add(st)",
"-print((len(S)))",
"+ D[a] = 1",
"+ans = 0",
"+for i in D:",
"+ if D[i] % 2 == 1:",
"+ ans += 1",
"+print(ans)"
] | false
| 0.038711
| 0.046385
| 0.834565
|
[
"s768179386",
"s478182707"
] |
u906651641
|
p03455
|
python
|
s128711358
|
s312271667
| 20
| 18
| 2,940
| 2,940
|
Accepted
|
Accepted
| 10
|
a = list(map(int, input().split()))
if(a[0] * a[1] % 2 == 0):
print('Even')
else:
print('Odd')
|
a,b = list(map(int, input().split()))
if(a * b % 2 == 0):
print('Even')
else:
print('Odd')
| 6
| 6
| 104
| 94
|
a = list(map(int, input().split()))
if a[0] * a[1] % 2 == 0:
print("Even")
else:
print("Odd")
|
a, b = list(map(int, input().split()))
if a * b % 2 == 0:
print("Even")
else:
print("Odd")
| false
| 0
|
[
"-a = list(map(int, input().split()))",
"-if a[0] * a[1] % 2 == 0:",
"+a, b = list(map(int, input().split()))",
"+if a * b % 2 == 0:"
] | false
| 0.060663
| 0.279319
| 0.217181
|
[
"s128711358",
"s312271667"
] |
u790710233
|
p04012
|
python
|
s582740469
|
s378591881
| 20
| 17
| 3,316
| 2,940
|
Accepted
|
Accepted
| 15
|
from collections import Counter
c = Counter(eval(input()))
print(('Yes' if sum(v % 2 for v in list(c.values())) == 0 else 'No'))
|
w = eval(input())
print(('Yes' if sum(w.count(c) % 2 for c in w) == 0 else 'No'))
| 3
| 2
| 117
| 75
|
from collections import Counter
c = Counter(eval(input()))
print(("Yes" if sum(v % 2 for v in list(c.values())) == 0 else "No"))
|
w = eval(input())
print(("Yes" if sum(w.count(c) % 2 for c in w) == 0 else "No"))
| false
| 33.333333
|
[
"-from collections import Counter",
"-",
"-c = Counter(eval(input()))",
"-print((\"Yes\" if sum(v % 2 for v in list(c.values())) == 0 else \"No\"))",
"+w = eval(input())",
"+print((\"Yes\" if sum(w.count(c) % 2 for c in w) == 0 else \"No\"))"
] | false
| 0.046077
| 0.044909
| 1.026013
|
[
"s582740469",
"s378591881"
] |
u493520238
|
p02762
|
python
|
s425085928
|
s981108380
| 1,247
| 579
| 64,620
| 101,584
|
Accepted
|
Accepted
| 53.57
|
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def main():
n, m, k = list(map(int, input().split()))
uf = UnionFind(n)
no_cnt_list = [ set() for _ in range(n)]
for i in range(m):
a, b = list(map(int, input().split()))
uf.union(a-1,b-1)
no_cnt_list[a-1].add(b-1)
no_cnt_list[b-1].add(a-1)
for i in range(k):
c, d = list(map(int, input().split()))
if uf.same(c-1,d-1):
no_cnt_list[c-1].add(d-1)
no_cnt_list[d-1].add(c-1)
ans_l = []
for i in range(n):
all_cnt = uf.size(i)
ans = all_cnt - 1 - len(no_cnt_list[i])
ans_l.append(ans)
print((*ans_l))
if __name__ == "__main__":
main()
|
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
# too slow
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def get_all_members(self):
pare_d = {}
for i in range(self.n):
parent = self.find(i)
pare_d.setdefault(parent,[])
pare_d[parent].append(i)
return list(pare_d.values())
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
n,m,k = list(map(int, input().split()))
uf = UnionFind(n+1)
direct_cnts = [0]*(n+1)
for _ in range(m):
a,b = list(map(int, input().split()))
uf.union(a,b)
direct_cnts[a] += 1
direct_cnts[b] += 1
block = [[] for _ in range(n+1)]
for _ in range(k):
c,d = list(map(int, input().split()))
block[c].append(d)
block[d].append(c)
ansl = []
for i in range(1,n+1):
cnt = uf.size(i)-1
cnt -= direct_cnts[i]
for b in block[i]:
if uf.same(i,b): cnt -= 1
ansl.append(cnt)
print((*ansl))
| 76
| 84
| 1,875
| 1,990
|
class UnionFind:
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return "\n".join("{}: {}".format(r, self.members(r)) for r in self.roots())
def main():
n, m, k = list(map(int, input().split()))
uf = UnionFind(n)
no_cnt_list = [set() for _ in range(n)]
for i in range(m):
a, b = list(map(int, input().split()))
uf.union(a - 1, b - 1)
no_cnt_list[a - 1].add(b - 1)
no_cnt_list[b - 1].add(a - 1)
for i in range(k):
c, d = list(map(int, input().split()))
if uf.same(c - 1, d - 1):
no_cnt_list[c - 1].add(d - 1)
no_cnt_list[d - 1].add(c - 1)
ans_l = []
for i in range(n):
all_cnt = uf.size(i)
ans = all_cnt - 1 - len(no_cnt_list[i])
ans_l.append(ans)
print((*ans_l))
if __name__ == "__main__":
main()
|
class UnionFind:
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
# too slow
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def get_all_members(self):
pare_d = {}
for i in range(self.n):
parent = self.find(i)
pare_d.setdefault(parent, [])
pare_d[parent].append(i)
return list(pare_d.values())
def __str__(self):
return "\n".join("{}: {}".format(r, self.members(r)) for r in self.roots())
n, m, k = list(map(int, input().split()))
uf = UnionFind(n + 1)
direct_cnts = [0] * (n + 1)
for _ in range(m):
a, b = list(map(int, input().split()))
uf.union(a, b)
direct_cnts[a] += 1
direct_cnts[b] += 1
block = [[] for _ in range(n + 1)]
for _ in range(k):
c, d = list(map(int, input().split()))
block[c].append(d)
block[d].append(c)
ansl = []
for i in range(1, n + 1):
cnt = uf.size(i) - 1
cnt -= direct_cnts[i]
for b in block[i]:
if uf.same(i, b):
cnt -= 1
ansl.append(cnt)
print((*ansl))
| false
| 9.52381
|
[
"+ # too slow",
"+",
"+ def get_all_members(self):",
"+ pare_d = {}",
"+ for i in range(self.n):",
"+ parent = self.find(i)",
"+ pare_d.setdefault(parent, [])",
"+ pare_d[parent].append(i)",
"+ return list(pare_d.values())",
"-def main():",
"- n, m, k = list(map(int, input().split()))",
"- uf = UnionFind(n)",
"- no_cnt_list = [set() for _ in range(n)]",
"- for i in range(m):",
"- a, b = list(map(int, input().split()))",
"- uf.union(a - 1, b - 1)",
"- no_cnt_list[a - 1].add(b - 1)",
"- no_cnt_list[b - 1].add(a - 1)",
"- for i in range(k):",
"- c, d = list(map(int, input().split()))",
"- if uf.same(c - 1, d - 1):",
"- no_cnt_list[c - 1].add(d - 1)",
"- no_cnt_list[d - 1].add(c - 1)",
"- ans_l = []",
"- for i in range(n):",
"- all_cnt = uf.size(i)",
"- ans = all_cnt - 1 - len(no_cnt_list[i])",
"- ans_l.append(ans)",
"- print((*ans_l))",
"-",
"-",
"-if __name__ == \"__main__\":",
"- main()",
"+n, m, k = list(map(int, input().split()))",
"+uf = UnionFind(n + 1)",
"+direct_cnts = [0] * (n + 1)",
"+for _ in range(m):",
"+ a, b = list(map(int, input().split()))",
"+ uf.union(a, b)",
"+ direct_cnts[a] += 1",
"+ direct_cnts[b] += 1",
"+block = [[] for _ in range(n + 1)]",
"+for _ in range(k):",
"+ c, d = list(map(int, input().split()))",
"+ block[c].append(d)",
"+ block[d].append(c)",
"+ansl = []",
"+for i in range(1, n + 1):",
"+ cnt = uf.size(i) - 1",
"+ cnt -= direct_cnts[i]",
"+ for b in block[i]:",
"+ if uf.same(i, b):",
"+ cnt -= 1",
"+ ansl.append(cnt)",
"+print((*ansl))"
] | false
| 0.046095
| 0.037399
| 1.232525
|
[
"s425085928",
"s981108380"
] |
u156815136
|
p03352
|
python
|
s946559986
|
s890886352
| 104
| 40
| 73,012
| 10,344
|
Accepted
|
Accepted
| 61.54
|
#from statistics import median
#import collections
#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]
from fractions import gcd
from itertools import combinations,permutations,accumulate # (string,3) 3回
#from collections import deque
from collections import deque,defaultdict,Counter
import decimal
import re
#import bisect
#
# d = m - k[i] - k[j]
# if kk[bisect.bisect_right(kk,d) - 1] == d:
#
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#
# my_round_int = lambda x:np.round((x*2 + 1)//2)
# 四捨五入
import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7
#mod = 9982443453
def readInts():
return list(map(int,input().split()))
def I():
return int(eval(input()))
x = I()
ma = 1
for b in range(1,x+1):
for p in range(2,x+1):
if b**p <= x:
ma = max(ma,b**p)
else:
break
print(ma)
|
#from statistics import median
#import collections
#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]
from fractions import gcd
from itertools import combinations,permutations,accumulate, product # (string,3) 3回
#from collections import deque
from collections import deque,defaultdict,Counter
import decimal
import re
import math
#
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#
# my_round_int = lambda x:np.round((x*2 + 1)//2)
# 四捨五入g
#
# インデックス系
# int min_y = max(0, i - 2), max_y = min(h - 1, i + 2);
# int min_x = max(0, j - 2), max_x = min(w - 1, j + 2);
#
#
import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7
#mod = 9982443453
#mod = 998244353
from sys import stdin
readline = stdin.readline
def readInts():
return list(map(int,readline().split()))
def readTuples():
return tuple(map(int,readline().split()))
def I():
return int(readline())
x = I()
ans = -1
for b in range(1,x+2):
for p in range(2, x+2):
if b**p > x:
break
ans = max(ans, b**p)
print(ans)
| 38
| 46
| 890
| 1,082
|
# from statistics import median
# import collections
# aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]
from fractions import gcd
from itertools import combinations, permutations, accumulate # (string,3) 3回
# from collections import deque
from collections import deque, defaultdict, Counter
import decimal
import re
# import bisect
#
# d = m - k[i] - k[j]
# if kk[bisect.bisect_right(kk,d) - 1] == d:
#
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#
# my_round_int = lambda x:np.round((x*2 + 1)//2)
# 四捨五入
import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7
# mod = 9982443453
def readInts():
return list(map(int, input().split()))
def I():
return int(eval(input()))
x = I()
ma = 1
for b in range(1, x + 1):
for p in range(2, x + 1):
if b**p <= x:
ma = max(ma, b**p)
else:
break
print(ma)
|
# from statistics import median
# import collections
# aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]
from fractions import gcd
from itertools import combinations, permutations, accumulate, product # (string,3) 3回
# from collections import deque
from collections import deque, defaultdict, Counter
import decimal
import re
import math
#
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#
# my_round_int = lambda x:np.round((x*2 + 1)//2)
# 四捨五入g
#
# インデックス系
# int min_y = max(0, i - 2), max_y = min(h - 1, i + 2);
# int min_x = max(0, j - 2), max_x = min(w - 1, j + 2);
#
#
import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7
# mod = 9982443453
# mod = 998244353
from sys import stdin
readline = stdin.readline
def readInts():
return list(map(int, readline().split()))
def readTuples():
return tuple(map(int, readline().split()))
def I():
return int(readline())
x = I()
ans = -1
for b in range(1, x + 2):
for p in range(2, x + 2):
if b**p > x:
break
ans = max(ans, b**p)
print(ans)
| false
| 17.391304
|
[
"-from itertools import combinations, permutations, accumulate # (string,3) 3回",
"+from itertools import combinations, permutations, accumulate, product # (string,3) 3回",
"+import math",
"-# import bisect",
"-#",
"-# d = m - k[i] - k[j]",
"-# if kk[bisect.bisect_right(kk,d) - 1] == d:",
"-# 四捨五入",
"+# 四捨五入g",
"+#",
"+# インデックス系",
"+# int min_y = max(0, i - 2), max_y = min(h - 1, i + 2);",
"+# int min_x = max(0, j - 2), max_x = min(w - 1, j + 2);",
"+#",
"+#",
"+# mod = 998244353",
"+from sys import stdin",
"+",
"+readline = stdin.readline",
"+",
"+",
"- return list(map(int, input().split()))",
"+ return list(map(int, readline().split()))",
"+",
"+",
"+def readTuples():",
"+ return tuple(map(int, readline().split()))",
"- return int(eval(input()))",
"+ return int(readline())",
"-ma = 1",
"-for b in range(1, x + 1):",
"- for p in range(2, x + 1):",
"- if b**p <= x:",
"- ma = max(ma, b**p)",
"- else:",
"+ans = -1",
"+for b in range(1, x + 2):",
"+ for p in range(2, x + 2):",
"+ if b**p > x:",
"-print(ma)",
"+ ans = max(ans, b**p)",
"+print(ans)"
] | false
| 0.047609
| 0.038764
| 1.228177
|
[
"s946559986",
"s890886352"
] |
u323680411
|
p03208
|
python
|
s920563291
|
s220389975
| 264
| 242
| 7,384
| 8,280
|
Accepted
|
Accepted
| 8.33
|
import sys
def main() -> None:
n, k = [int(s) for s in input().split()]
h = []
for i in range(n):
h += [int(eval(input()))]
h.sort()
mn = sys.maxsize
for i in range(n - k + 1):
cnt = h[i + k - 1] - h[i]
mn = min(mn, cnt)
print(mn)
if __name__ == '__main__':
main()
|
import sys
n, k = [int(s) for s in input().split()]
h = sorted([int(eval(input())) for _ in range(n)])
mn = sys.maxsize
for i in range(n - k + 1):
cnt = h[i + k - 1] - h[i]
mn = min(mn, cnt)
print(mn)
| 20
| 11
| 339
| 215
|
import sys
def main() -> None:
n, k = [int(s) for s in input().split()]
h = []
for i in range(n):
h += [int(eval(input()))]
h.sort()
mn = sys.maxsize
for i in range(n - k + 1):
cnt = h[i + k - 1] - h[i]
mn = min(mn, cnt)
print(mn)
if __name__ == "__main__":
main()
|
import sys
n, k = [int(s) for s in input().split()]
h = sorted([int(eval(input())) for _ in range(n)])
mn = sys.maxsize
for i in range(n - k + 1):
cnt = h[i + k - 1] - h[i]
mn = min(mn, cnt)
print(mn)
| false
| 45
|
[
"-",
"-def main() -> None:",
"- n, k = [int(s) for s in input().split()]",
"- h = []",
"- for i in range(n):",
"- h += [int(eval(input()))]",
"- h.sort()",
"- mn = sys.maxsize",
"- for i in range(n - k + 1):",
"- cnt = h[i + k - 1] - h[i]",
"- mn = min(mn, cnt)",
"- print(mn)",
"-",
"-",
"-if __name__ == \"__main__\":",
"- main()",
"+n, k = [int(s) for s in input().split()]",
"+h = sorted([int(eval(input())) for _ in range(n)])",
"+mn = sys.maxsize",
"+for i in range(n - k + 1):",
"+ cnt = h[i + k - 1] - h[i]",
"+ mn = min(mn, cnt)",
"+print(mn)"
] | false
| 0.074757
| 0.079528
| 0.940006
|
[
"s920563291",
"s220389975"
] |
u515740713
|
p03450
|
python
|
s242668971
|
s871983773
| 675
| 516
| 71,300
| 14,832
|
Accepted
|
Accepted
| 23.56
|
# -*- coding: utf-8 -*-
### 幅優先探索により矛盾を探す
import sys
from collections import deque
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N,M = list(map(int,readline().split()))
graph = [[] for _ in range(N)]
for _ in range(M):
L,R,D = list(map(int,readline().split()))
graph[L-1].append((R-1,D))
graph[R-1].append((L-1,-D))
dist = [0]*N
done = [0]*N
def bfs(i):
q = deque([i])
while q:
x = q.popleft()
for y,d in graph[x]:
if done[y] == 0:
done[y] = 1
dist[y] = dist[x]+ d
q.append(y)
else:
if dist[y] != dist[x]+d:
return 0
return 1
for i in range(N):
if done[i] == 0:
done[i] = 1
if bfs(i) == 0:
print('No')
sys.exit()
print('Yes')
|
# -*- coding: utf-8 -*-
#重み付きUnion-Findによる実装
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
#xの根を求める
def find(x):
if par[x] < 0:
return x
else:
px = find(par[x])
wei[x] += wei[par[x]]
par[x] = px
return px
#xの根から距離
def weight(x):
find(x)
return wei[x]
#w[y]=w[x]+wとなるようにxとyを併合
def unite(x,y,w):
w += wei[x]-wei[y]
x = find(x)
y = find(y)
if x == y:
return False
else:
#sizeの大きいほうがx
if par[x] > par[y]:
x,y = y,x
w = -w
par[x] += par[y]
par[y] = x
wei[y] = w
return True
#xとyが同じ集合に属するかの判定
def same(x,y):
return find(x) == find(y)
#xが属する集合の個数
def size(x):
return -par[find(x)]
#x,yが同じ集合に属するときのwei[y]-wei[x]
def diff(x,y):
return weight(y)-weight(x)
N,M = list(map(int,readline().split()))
#0-index
par = [-1]*N
wei = [0]*N
for _ in range(M):
l,r,d = list(map(int,readline().split()))
l,r = l-1,r-1
if same(l,r):
if d != diff(l,r):
print('No')
exit()
else:
unite(l,r,d)
print('Yes')
| 38
| 67
| 906
| 1,239
|
# -*- coding: utf-8 -*-
### 幅優先探索により矛盾を探す
import sys
from collections import deque
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N, M = list(map(int, readline().split()))
graph = [[] for _ in range(N)]
for _ in range(M):
L, R, D = list(map(int, readline().split()))
graph[L - 1].append((R - 1, D))
graph[R - 1].append((L - 1, -D))
dist = [0] * N
done = [0] * N
def bfs(i):
q = deque([i])
while q:
x = q.popleft()
for y, d in graph[x]:
if done[y] == 0:
done[y] = 1
dist[y] = dist[x] + d
q.append(y)
else:
if dist[y] != dist[x] + d:
return 0
return 1
for i in range(N):
if done[i] == 0:
done[i] = 1
if bfs(i) == 0:
print("No")
sys.exit()
print("Yes")
|
# -*- coding: utf-8 -*-
# 重み付きUnion-Findによる実装
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
# xの根を求める
def find(x):
if par[x] < 0:
return x
else:
px = find(par[x])
wei[x] += wei[par[x]]
par[x] = px
return px
# xの根から距離
def weight(x):
find(x)
return wei[x]
# w[y]=w[x]+wとなるようにxとyを併合
def unite(x, y, w):
w += wei[x] - wei[y]
x = find(x)
y = find(y)
if x == y:
return False
else:
# sizeの大きいほうがx
if par[x] > par[y]:
x, y = y, x
w = -w
par[x] += par[y]
par[y] = x
wei[y] = w
return True
# xとyが同じ集合に属するかの判定
def same(x, y):
return find(x) == find(y)
# xが属する集合の個数
def size(x):
return -par[find(x)]
# x,yが同じ集合に属するときのwei[y]-wei[x]
def diff(x, y):
return weight(y) - weight(x)
N, M = list(map(int, readline().split()))
# 0-index
par = [-1] * N
wei = [0] * N
for _ in range(M):
l, r, d = list(map(int, readline().split()))
l, r = l - 1, r - 1
if same(l, r):
if d != diff(l, r):
print("No")
exit()
else:
unite(l, r, d)
print("Yes")
| false
| 43.283582
|
[
"-### 幅優先探索により矛盾を探す",
"+# 重み付きUnion-Findによる実装",
"-from collections import deque",
"-N, M = list(map(int, readline().split()))",
"-graph = [[] for _ in range(N)]",
"-for _ in range(M):",
"- L, R, D = list(map(int, readline().split()))",
"- graph[L - 1].append((R - 1, D))",
"- graph[R - 1].append((L - 1, -D))",
"-dist = [0] * N",
"-done = [0] * N",
"+# xの根を求める",
"+def find(x):",
"+ if par[x] < 0:",
"+ return x",
"+ else:",
"+ px = find(par[x])",
"+ wei[x] += wei[par[x]]",
"+ par[x] = px",
"+ return px",
"-def bfs(i):",
"- q = deque([i])",
"- while q:",
"- x = q.popleft()",
"- for y, d in graph[x]:",
"- if done[y] == 0:",
"- done[y] = 1",
"- dist[y] = dist[x] + d",
"- q.append(y)",
"- else:",
"- if dist[y] != dist[x] + d:",
"- return 0",
"- return 1",
"+# xの根から距離",
"+def weight(x):",
"+ find(x)",
"+ return wei[x]",
"-for i in range(N):",
"- if done[i] == 0:",
"- done[i] = 1",
"- if bfs(i) == 0:",
"+# w[y]=w[x]+wとなるようにxとyを併合",
"+def unite(x, y, w):",
"+ w += wei[x] - wei[y]",
"+ x = find(x)",
"+ y = find(y)",
"+ if x == y:",
"+ return False",
"+ else:",
"+ # sizeの大きいほうがx",
"+ if par[x] > par[y]:",
"+ x, y = y, x",
"+ w = -w",
"+ par[x] += par[y]",
"+ par[y] = x",
"+ wei[y] = w",
"+ return True",
"+",
"+",
"+# xとyが同じ集合に属するかの判定",
"+def same(x, y):",
"+ return find(x) == find(y)",
"+",
"+",
"+# xが属する集合の個数",
"+def size(x):",
"+ return -par[find(x)]",
"+",
"+",
"+# x,yが同じ集合に属するときのwei[y]-wei[x]",
"+def diff(x, y):",
"+ return weight(y) - weight(x)",
"+",
"+",
"+N, M = list(map(int, readline().split()))",
"+# 0-index",
"+par = [-1] * N",
"+wei = [0] * N",
"+for _ in range(M):",
"+ l, r, d = list(map(int, readline().split()))",
"+ l, r = l - 1, r - 1",
"+ if same(l, r):",
"+ if d != diff(l, r):",
"- sys.exit()",
"+ exit()",
"+ else:",
"+ unite(l, r, d)"
] | false
| 0.114137
| 0.042231
| 2.702666
|
[
"s242668971",
"s871983773"
] |
u462329577
|
p03352
|
python
|
s501671083
|
s162846376
| 170
| 17
| 38,256
| 2,940
|
Accepted
|
Accepted
| 90
|
def ans(n):
pow_2 = int(n**(0.5))
pow_exeption = [32,128,243]
#print(pow_2)
ans = pow_2**2
for i in pow_exeption:
if i <= n:
ans = max(i,ans)
for i in range(1,11):
if i**3 <= n:
ans = max((i**3),ans)
return(ans)
n = int(eval(input()))
for i in range(n,n+1):
print((ans(i)))
|
#!/usr/bin/env python3
x = int(eval(input()))
ans = 1
for i in range(2,int(x**1/2) + 1):
p = 2
while True:
if i**p > x: break
else:
ans = max(ans,i**p)
p += 1
print(ans)
| 16
| 11
| 361
| 221
|
def ans(n):
pow_2 = int(n ** (0.5))
pow_exeption = [32, 128, 243]
# print(pow_2)
ans = pow_2**2
for i in pow_exeption:
if i <= n:
ans = max(i, ans)
for i in range(1, 11):
if i**3 <= n:
ans = max((i**3), ans)
return ans
n = int(eval(input()))
for i in range(n, n + 1):
print((ans(i)))
|
#!/usr/bin/env python3
x = int(eval(input()))
ans = 1
for i in range(2, int(x**1 / 2) + 1):
p = 2
while True:
if i**p > x:
break
else:
ans = max(ans, i**p)
p += 1
print(ans)
| false
| 31.25
|
[
"-def ans(n):",
"- pow_2 = int(n ** (0.5))",
"- pow_exeption = [32, 128, 243]",
"- # print(pow_2)",
"- ans = pow_2**2",
"- for i in pow_exeption:",
"- if i <= n:",
"- ans = max(i, ans)",
"- for i in range(1, 11):",
"- if i**3 <= n:",
"- ans = max((i**3), ans)",
"- return ans",
"-",
"-",
"-n = int(eval(input()))",
"-for i in range(n, n + 1):",
"- print((ans(i)))",
"+#!/usr/bin/env python3",
"+x = int(eval(input()))",
"+ans = 1",
"+for i in range(2, int(x**1 / 2) + 1):",
"+ p = 2",
"+ while True:",
"+ if i**p > x:",
"+ break",
"+ else:",
"+ ans = max(ans, i**p)",
"+ p += 1",
"+print(ans)"
] | false
| 0.118739
| 0.041427
| 2.866239
|
[
"s501671083",
"s162846376"
] |
u131638468
|
p03805
|
python
|
s131431336
|
s773783358
| 80
| 64
| 4,468
| 3,064
|
Accepted
|
Accepted
| 20
|
n,m=list(map(int,input().split()))
edge=[list(map(int,input().split())) for i in range(m)]
ans=0
rout=[[0 for i in range(n)]]
rout[0][0]=1
for i in range(2,n+1):
rout2=[]
for j in range(len(rout)):
for k in range(n):
if rout[j][k]==0:
r=rout[j][:]
r[k]=i
rout2.append(r)
rout=rout2
for r in rout:
lim=0
while lim<n-1:
if [r[lim],r[lim+1]] in edge or [r[lim+1],r[lim]] in edge:
lim+=1
else:
lim=0
break
if lim:
ans+=1
print(ans)
|
import itertools
n,m=list(map(int,input().split()))
edge=[list(map(int,input().split())) for i in range(m)]
ans=0
nums=[i for i in range(1,n+1)]
rout=itertools.permutations(nums,n)
for r in rout:
if r[0]!=1:
continue
lim=0
while lim<n-1:
if [r[lim],r[lim+1]] in edge or [r[lim+1],r[lim]] in edge:
lim+=1
else:
lim=0
break
if lim:
ans+=1
print(ans)
| 25
| 19
| 521
| 401
|
n, m = list(map(int, input().split()))
edge = [list(map(int, input().split())) for i in range(m)]
ans = 0
rout = [[0 for i in range(n)]]
rout[0][0] = 1
for i in range(2, n + 1):
rout2 = []
for j in range(len(rout)):
for k in range(n):
if rout[j][k] == 0:
r = rout[j][:]
r[k] = i
rout2.append(r)
rout = rout2
for r in rout:
lim = 0
while lim < n - 1:
if [r[lim], r[lim + 1]] in edge or [r[lim + 1], r[lim]] in edge:
lim += 1
else:
lim = 0
break
if lim:
ans += 1
print(ans)
|
import itertools
n, m = list(map(int, input().split()))
edge = [list(map(int, input().split())) for i in range(m)]
ans = 0
nums = [i for i in range(1, n + 1)]
rout = itertools.permutations(nums, n)
for r in rout:
if r[0] != 1:
continue
lim = 0
while lim < n - 1:
if [r[lim], r[lim + 1]] in edge or [r[lim + 1], r[lim]] in edge:
lim += 1
else:
lim = 0
break
if lim:
ans += 1
print(ans)
| false
| 24
|
[
"+import itertools",
"+",
"-rout = [[0 for i in range(n)]]",
"-rout[0][0] = 1",
"-for i in range(2, n + 1):",
"- rout2 = []",
"- for j in range(len(rout)):",
"- for k in range(n):",
"- if rout[j][k] == 0:",
"- r = rout[j][:]",
"- r[k] = i",
"- rout2.append(r)",
"- rout = rout2",
"+nums = [i for i in range(1, n + 1)]",
"+rout = itertools.permutations(nums, n)",
"+ if r[0] != 1:",
"+ continue"
] | false
| 0.072914
| 0.106307
| 0.685878
|
[
"s131431336",
"s773783358"
] |
u243312682
|
p02601
|
python
|
s720601969
|
s707868214
| 37
| 27
| 9,196
| 9,088
|
Accepted
|
Accepted
| 27.03
|
def main():
a, b, c = list(map(int, input().split()))
k = int(eval(input()))
while b <= a:
b *= 2
k -= 1
if k < 0:
print('No')
exit()
while c <= b:
c *= 2
k -= 1
if k < 0:
print('No')
exit()
if a < b < c:
print('Yes')
else:
print('No')
if __name__ == '__main__':
main()
|
def main():
a, b, c = list(map(int, input().split()))
k = int(eval(input()))
while b <= a:
b *= 2
k -= 1
if k < 0:
print('No')
exit()
while c <= b:
c *= 2
k -= 1
if k < 0:
print('No')
exit()
print('Yes')
if __name__ == '__main__':
main()
| 22
| 19
| 419
| 369
|
def main():
a, b, c = list(map(int, input().split()))
k = int(eval(input()))
while b <= a:
b *= 2
k -= 1
if k < 0:
print("No")
exit()
while c <= b:
c *= 2
k -= 1
if k < 0:
print("No")
exit()
if a < b < c:
print("Yes")
else:
print("No")
if __name__ == "__main__":
main()
|
def main():
a, b, c = list(map(int, input().split()))
k = int(eval(input()))
while b <= a:
b *= 2
k -= 1
if k < 0:
print("No")
exit()
while c <= b:
c *= 2
k -= 1
if k < 0:
print("No")
exit()
print("Yes")
if __name__ == "__main__":
main()
| false
| 13.636364
|
[
"- if a < b < c:",
"- print(\"Yes\")",
"- else:",
"- print(\"No\")",
"+ print(\"Yes\")"
] | false
| 0.03662
| 0.036337
| 1.007785
|
[
"s720601969",
"s707868214"
] |
u790012205
|
p03854
|
python
|
s034523203
|
s726481104
| 72
| 57
| 3,188
| 9,180
|
Accepted
|
Accepted
| 20.83
|
import sys
S = input()[::-1]
t = ['dream'[::-1], 'dreamer'[::-1], 'erase'[::-1], 'eraser'[::-1]]
while len(S) > 0:
if S[:5] == t[0]:
S = S[5:]
elif S[:7] == t[1]:
S = S[7:]
elif S[:5] == t[2]:
S = S[5:]
elif S[:6] == t[3]:
S = S[6:]
else:
print('NO')
sys.exit()
print('YES')
|
import sys
S = eval(input())
S = S[::-1]
while S != '':
if S[:5] == 'maerd':
S = S[5:]
elif S[:5] == 'esare':
S = S[5:]
elif S[:6] == 'resare':
S = S[6:]
elif S[:7] == 'remaerd':
S = S[7:]
else:
print('NO')
exit()
print('YES')
| 16
| 16
| 357
| 303
|
import sys
S = input()[::-1]
t = ["dream"[::-1], "dreamer"[::-1], "erase"[::-1], "eraser"[::-1]]
while len(S) > 0:
if S[:5] == t[0]:
S = S[5:]
elif S[:7] == t[1]:
S = S[7:]
elif S[:5] == t[2]:
S = S[5:]
elif S[:6] == t[3]:
S = S[6:]
else:
print("NO")
sys.exit()
print("YES")
|
import sys
S = eval(input())
S = S[::-1]
while S != "":
if S[:5] == "maerd":
S = S[5:]
elif S[:5] == "esare":
S = S[5:]
elif S[:6] == "resare":
S = S[6:]
elif S[:7] == "remaerd":
S = S[7:]
else:
print("NO")
exit()
print("YES")
| false
| 0
|
[
"-S = input()[::-1]",
"-t = [\"dream\"[::-1], \"dreamer\"[::-1], \"erase\"[::-1], \"eraser\"[::-1]]",
"-while len(S) > 0:",
"- if S[:5] == t[0]:",
"+S = eval(input())",
"+S = S[::-1]",
"+while S != \"\":",
"+ if S[:5] == \"maerd\":",
"- elif S[:7] == t[1]:",
"+ elif S[:5] == \"esare\":",
"+ S = S[5:]",
"+ elif S[:6] == \"resare\":",
"+ S = S[6:]",
"+ elif S[:7] == \"remaerd\":",
"- elif S[:5] == t[2]:",
"- S = S[5:]",
"- elif S[:6] == t[3]:",
"- S = S[6:]",
"- sys.exit()",
"+ exit()"
] | false
| 0.072189
| 0.033569
| 2.150427
|
[
"s034523203",
"s726481104"
] |
u670180528
|
p03724
|
python
|
s848470344
|
s924038993
| 328
| 98
| 3,956
| 25,076
|
Accepted
|
Accepted
| 70.12
|
n,m = list(map(int,input().split()))
cnt = [0]*(n+1)
for _ in range(m):
a,b = list(map(int,input().split()))
cnt[a] ^= 1
cnt[b] ^= 1
for i in cnt:
if i:
print("NO")
exit()
print("YES")
|
n,_,*l=list(map(int,open(0).read().split()))
c=[0]*-~n
for a,b in zip(l[::2],l[1::2]):
c[a]^=1;c[b]^=1
print(("YNEOS"[any(i for i in c)::2]))
| 11
| 5
| 190
| 138
|
n, m = list(map(int, input().split()))
cnt = [0] * (n + 1)
for _ in range(m):
a, b = list(map(int, input().split()))
cnt[a] ^= 1
cnt[b] ^= 1
for i in cnt:
if i:
print("NO")
exit()
print("YES")
|
n, _, *l = list(map(int, open(0).read().split()))
c = [0] * -~n
for a, b in zip(l[::2], l[1::2]):
c[a] ^= 1
c[b] ^= 1
print(("YNEOS"[any(i for i in c) :: 2]))
| false
| 54.545455
|
[
"-n, m = list(map(int, input().split()))",
"-cnt = [0] * (n + 1)",
"-for _ in range(m):",
"- a, b = list(map(int, input().split()))",
"- cnt[a] ^= 1",
"- cnt[b] ^= 1",
"-for i in cnt:",
"- if i:",
"- print(\"NO\")",
"- exit()",
"-print(\"YES\")",
"+n, _, *l = list(map(int, open(0).read().split()))",
"+c = [0] * -~n",
"+for a, b in zip(l[::2], l[1::2]):",
"+ c[a] ^= 1",
"+ c[b] ^= 1",
"+print((\"YNEOS\"[any(i for i in c) :: 2]))"
] | false
| 0.035269
| 0.076162
| 0.463077
|
[
"s848470344",
"s924038993"
] |
u621935300
|
p03329
|
python
|
s868729768
|
s870277313
| 263
| 155
| 34,584
| 34,156
|
Accepted
|
Accepted
| 41.06
|
import copy
N=eval(input())
def nine(m):
if m<9: return m
for i in range(1000):
t=9**i
if t>m:
t1=9**(i-1)
return m-t1
def six(m):
if m<6: return m
for i in range(1000):
t=6**i
if t>m:
t2=6**(i-1)
return m-t2
Z=15
k=1<<Z
b=set()
for i in range(k):
n=copy.deepcopy(N)
ans=0
for j in range(Z):
if n<6:
b.add(ans+n)
break
if i&(1<<j)!=0:
#9
n=nine(n)
ans+=1
else:
#6
n=six(n)
ans+=1
print(min(b))
|
N=eval(input())
dp=[ float("inf") for i in range(N+1) ]
dp[0]=0
i=1
for i in range(1,8):
for n in range(N):
if n+ 9**i <=N: dp[ n+ 9**i ]=min( dp[n]+1, dp[ n+9**i ] )
if n+ 6**i <=N: dp[ n+ 6**i ]=min( dp[n]+1, dp[ n+6**i ] )
if n+ 1 <=N: dp[ n+ 1 ]=min( dp[n]+1, dp[ n+1 ] )
print(dp[N])
| 44
| 15
| 496
| 312
|
import copy
N = eval(input())
def nine(m):
if m < 9:
return m
for i in range(1000):
t = 9**i
if t > m:
t1 = 9 ** (i - 1)
return m - t1
def six(m):
if m < 6:
return m
for i in range(1000):
t = 6**i
if t > m:
t2 = 6 ** (i - 1)
return m - t2
Z = 15
k = 1 << Z
b = set()
for i in range(k):
n = copy.deepcopy(N)
ans = 0
for j in range(Z):
if n < 6:
b.add(ans + n)
break
if i & (1 << j) != 0:
# 9
n = nine(n)
ans += 1
else:
# 6
n = six(n)
ans += 1
print(min(b))
|
N = eval(input())
dp = [float("inf") for i in range(N + 1)]
dp[0] = 0
i = 1
for i in range(1, 8):
for n in range(N):
if n + 9**i <= N:
dp[n + 9**i] = min(dp[n] + 1, dp[n + 9**i])
if n + 6**i <= N:
dp[n + 6**i] = min(dp[n] + 1, dp[n + 6**i])
if n + 1 <= N:
dp[n + 1] = min(dp[n] + 1, dp[n + 1])
print(dp[N])
| false
| 65.909091
|
[
"-import copy",
"-",
"-",
"-",
"-def nine(m):",
"- if m < 9:",
"- return m",
"- for i in range(1000):",
"- t = 9**i",
"- if t > m:",
"- t1 = 9 ** (i - 1)",
"- return m - t1",
"-",
"-",
"-def six(m):",
"- if m < 6:",
"- return m",
"- for i in range(1000):",
"- t = 6**i",
"- if t > m:",
"- t2 = 6 ** (i - 1)",
"- return m - t2",
"-",
"-",
"-Z = 15",
"-k = 1 << Z",
"-b = set()",
"-for i in range(k):",
"- n = copy.deepcopy(N)",
"- ans = 0",
"- for j in range(Z):",
"- if n < 6:",
"- b.add(ans + n)",
"- break",
"- if i & (1 << j) != 0:",
"- # 9",
"- n = nine(n)",
"- ans += 1",
"- else:",
"- # 6",
"- n = six(n)",
"- ans += 1",
"-print(min(b))",
"+dp = [float(\"inf\") for i in range(N + 1)]",
"+dp[0] = 0",
"+i = 1",
"+for i in range(1, 8):",
"+ for n in range(N):",
"+ if n + 9**i <= N:",
"+ dp[n + 9**i] = min(dp[n] + 1, dp[n + 9**i])",
"+ if n + 6**i <= N:",
"+ dp[n + 6**i] = min(dp[n] + 1, dp[n + 6**i])",
"+ if n + 1 <= N:",
"+ dp[n + 1] = min(dp[n] + 1, dp[n + 1])",
"+print(dp[N])"
] | false
| 0.818756
| 0.314754
| 2.601256
|
[
"s868729768",
"s870277313"
] |
u072053884
|
p02278
|
python
|
s265092064
|
s459315281
| 80
| 40
| 7,816
| 7,800
|
Accepted
|
Accepted
| 50
|
"""Minimum cost Sort."""
def make_cycle(A):
"""Return a list which has the minimum element of A and
switch elements cycles as list.
A is a list whose elements' type is 'int'.
Each cycle list has its minimum elements in the first index.
"""
B = list(A)
B.sort()
cycle_list = [B[0]]
for i, b in enumerate(B):
if b != None:
new_cycle = []
new_cycle.append(b)
B[i] = None
si = A.index(b)
while si != i:
st = B[si]
new_cycle.append(st)
B[si] = None
si = A.index(st)
cycle_list.append(new_cycle)
return cycle_list
def min_sorting_cost(A):
"""Return the minimum cost of sorting A.
A is a list whose elements' type is 'int'.
"""
cycles = make_cycle(A)
min_w = cycles[0]
cost = 0
for c in cycles[1:]:
n = len(c)
min_cw = c[0]
dec = (n - 1) * (min_cw - min_w)
inc = 2 * (min_w + min_cw)
if dec < inc:
cost += sum(c) + min_cw * (n - 2)
else:
cost += sum(c) + min_cw * (n - 2) - dec + inc
return cost
n = int(eval(input()))
A = list(map(int, input().split()))
ans = min_sorting_cost(A)
print(ans)
|
"""Minimum cost Sort."""
def min_cost_sort(A):
"""Sort list A in ascending order.
And return the switching cost in sorting.
"""
B = list(A)
B.sort()
cost = 0
min_w = B[0]
for i, b in enumerate(B):
tmp_cost = 0
bi = A.index(b)
n = 1
while bi != i:
n += 1
st = B[bi]
si = A.index(st)
tmp_cost += b + st
A[bi], A[si] = st, b
bi = si
dec = (n - 1) * (b - min_w)
inc = 2 * (min_w + b)
if dec < inc:
cost += tmp_cost
else:
cost += tmp_cost - dec + inc
return cost
n = eval(input())
A = list(map(int, input().split()))
ans = min_cost_sort(A)
print(ans)
| 54
| 38
| 1,329
| 780
|
"""Minimum cost Sort."""
def make_cycle(A):
"""Return a list which has the minimum element of A and
switch elements cycles as list.
A is a list whose elements' type is 'int'.
Each cycle list has its minimum elements in the first index.
"""
B = list(A)
B.sort()
cycle_list = [B[0]]
for i, b in enumerate(B):
if b != None:
new_cycle = []
new_cycle.append(b)
B[i] = None
si = A.index(b)
while si != i:
st = B[si]
new_cycle.append(st)
B[si] = None
si = A.index(st)
cycle_list.append(new_cycle)
return cycle_list
def min_sorting_cost(A):
"""Return the minimum cost of sorting A.
A is a list whose elements' type is 'int'.
"""
cycles = make_cycle(A)
min_w = cycles[0]
cost = 0
for c in cycles[1:]:
n = len(c)
min_cw = c[0]
dec = (n - 1) * (min_cw - min_w)
inc = 2 * (min_w + min_cw)
if dec < inc:
cost += sum(c) + min_cw * (n - 2)
else:
cost += sum(c) + min_cw * (n - 2) - dec + inc
return cost
n = int(eval(input()))
A = list(map(int, input().split()))
ans = min_sorting_cost(A)
print(ans)
|
"""Minimum cost Sort."""
def min_cost_sort(A):
"""Sort list A in ascending order.
And return the switching cost in sorting.
"""
B = list(A)
B.sort()
cost = 0
min_w = B[0]
for i, b in enumerate(B):
tmp_cost = 0
bi = A.index(b)
n = 1
while bi != i:
n += 1
st = B[bi]
si = A.index(st)
tmp_cost += b + st
A[bi], A[si] = st, b
bi = si
dec = (n - 1) * (b - min_w)
inc = 2 * (min_w + b)
if dec < inc:
cost += tmp_cost
else:
cost += tmp_cost - dec + inc
return cost
n = eval(input())
A = list(map(int, input().split()))
ans = min_cost_sort(A)
print(ans)
| false
| 29.62963
|
[
"-def make_cycle(A):",
"- \"\"\"Return a list which has the minimum element of A and",
"- switch elements cycles as list.",
"- A is a list whose elements' type is 'int'.",
"- Each cycle list has its minimum elements in the first index.",
"+def min_cost_sort(A):",
"+ \"\"\"Sort list A in ascending order.",
"+ And return the switching cost in sorting.",
"- cycle_list = [B[0]]",
"+ cost = 0",
"+ min_w = B[0]",
"- if b != None:",
"- new_cycle = []",
"- new_cycle.append(b)",
"- B[i] = None",
"- si = A.index(b)",
"- while si != i:",
"- st = B[si]",
"- new_cycle.append(st)",
"- B[si] = None",
"- si = A.index(st)",
"- cycle_list.append(new_cycle)",
"- return cycle_list",
"-",
"-",
"-def min_sorting_cost(A):",
"- \"\"\"Return the minimum cost of sorting A.",
"- A is a list whose elements' type is 'int'.",
"- \"\"\"",
"- cycles = make_cycle(A)",
"- min_w = cycles[0]",
"- cost = 0",
"- for c in cycles[1:]:",
"- n = len(c)",
"- min_cw = c[0]",
"- dec = (n - 1) * (min_cw - min_w)",
"- inc = 2 * (min_w + min_cw)",
"+ tmp_cost = 0",
"+ bi = A.index(b)",
"+ n = 1",
"+ while bi != i:",
"+ n += 1",
"+ st = B[bi]",
"+ si = A.index(st)",
"+ tmp_cost += b + st",
"+ A[bi], A[si] = st, b",
"+ bi = si",
"+ dec = (n - 1) * (b - min_w)",
"+ inc = 2 * (min_w + b)",
"- cost += sum(c) + min_cw * (n - 2)",
"+ cost += tmp_cost",
"- cost += sum(c) + min_cw * (n - 2) - dec + inc",
"+ cost += tmp_cost - dec + inc",
"-n = int(eval(input()))",
"+n = eval(input())",
"-ans = min_sorting_cost(A)",
"+ans = min_cost_sort(A)"
] | false
| 0.052696
| 0.098982
| 0.532384
|
[
"s265092064",
"s459315281"
] |
u021019433
|
p02708
|
python
|
s816019679
|
s351968411
| 45
| 23
| 9,160
| 9,168
|
Accepted
|
Accepted
| 48.89
|
n, k = list(map(int, input().split()))
print((sum(i * (n - i + 1) + 1 for i in range(k, n + 2))%(10**9 + 7)))
|
n, k = list(map(int, input().split()))
f = lambda i: (n + 1) * i * (i - 1) // 2 - i * (i - 1) * (2 * i - 1) // 6
print(((n - k + 2 + f(n + 2) - f(k)) % (10**9 + 7)))
| 2
| 3
| 103
| 161
|
n, k = list(map(int, input().split()))
print((sum(i * (n - i + 1) + 1 for i in range(k, n + 2)) % (10**9 + 7)))
|
n, k = list(map(int, input().split()))
f = lambda i: (n + 1) * i * (i - 1) // 2 - i * (i - 1) * (2 * i - 1) // 6
print(((n - k + 2 + f(n + 2) - f(k)) % (10**9 + 7)))
| false
| 33.333333
|
[
"-print((sum(i * (n - i + 1) + 1 for i in range(k, n + 2)) % (10**9 + 7)))",
"+f = lambda i: (n + 1) * i * (i - 1) // 2 - i * (i - 1) * (2 * i - 1) // 6",
"+print(((n - k + 2 + f(n + 2) - f(k)) % (10**9 + 7)))"
] | false
| 0.086236
| 0.053403
| 1.614797
|
[
"s816019679",
"s351968411"
] |
u747602774
|
p03503
|
python
|
s207811328
|
s288573816
| 310
| 259
| 3,064
| 3,064
|
Accepted
|
Accepted
| 16.45
|
import itertools
N = int(eval(input()))
F = [list(map(int,input().split())) for i in range(N)]
P = [list(map(int,input().split())) for i in range(N)]
#print(F)
#print(P)
ans = -10**10
for v in itertools.product([1,0],repeat=10):
if v != (0,0,0,0,0,0,0,0,0,0):
bene = 0
for i in range(N):
c = 0
for j in range(10):
if v[j] == F[i][j] == 1:
c += 1
bene += P[i][c]
ans = max(ans,bene)
print(ans)
|
n = int(eval(input()))
f = [list(map(int,input().split())) for i in range(n)]
p = [list(map(int,input().split())) for i in range(n)]
ans = -10**10
for i in range(1,2**10):
a = 0
for j in range(n):
a += p[j][sum(i>>k&1 and f[j][k] for k in range(10))]
ans = max(ans,a)
print(ans)
| 21
| 10
| 510
| 302
|
import itertools
N = int(eval(input()))
F = [list(map(int, input().split())) for i in range(N)]
P = [list(map(int, input().split())) for i in range(N)]
# print(F)
# print(P)
ans = -(10**10)
for v in itertools.product([1, 0], repeat=10):
if v != (0, 0, 0, 0, 0, 0, 0, 0, 0, 0):
bene = 0
for i in range(N):
c = 0
for j in range(10):
if v[j] == F[i][j] == 1:
c += 1
bene += P[i][c]
ans = max(ans, bene)
print(ans)
|
n = int(eval(input()))
f = [list(map(int, input().split())) for i in range(n)]
p = [list(map(int, input().split())) for i in range(n)]
ans = -(10**10)
for i in range(1, 2**10):
a = 0
for j in range(n):
a += p[j][sum(i >> k & 1 and f[j][k] for k in range(10))]
ans = max(ans, a)
print(ans)
| false
| 52.380952
|
[
"-import itertools",
"-",
"-N = int(eval(input()))",
"-F = [list(map(int, input().split())) for i in range(N)]",
"-P = [list(map(int, input().split())) for i in range(N)]",
"-# print(F)",
"-# print(P)",
"+n = int(eval(input()))",
"+f = [list(map(int, input().split())) for i in range(n)]",
"+p = [list(map(int, input().split())) for i in range(n)]",
"-for v in itertools.product([1, 0], repeat=10):",
"- if v != (0, 0, 0, 0, 0, 0, 0, 0, 0, 0):",
"- bene = 0",
"- for i in range(N):",
"- c = 0",
"- for j in range(10):",
"- if v[j] == F[i][j] == 1:",
"- c += 1",
"- bene += P[i][c]",
"- ans = max(ans, bene)",
"+for i in range(1, 2**10):",
"+ a = 0",
"+ for j in range(n):",
"+ a += p[j][sum(i >> k & 1 and f[j][k] for k in range(10))]",
"+ ans = max(ans, a)"
] | false
| 0.117506
| 0.053338
| 2.203067
|
[
"s207811328",
"s288573816"
] |
u653837719
|
p02574
|
python
|
s792849070
|
s906532424
| 669
| 429
| 234,836
| 195,700
|
Accepted
|
Accepted
| 35.87
|
from sys import exit
from math import gcd
def eratosthenes(n):
'''
n以下の整数の素数判定/列挙 (n > 1)
O(NloglogN)
'''
is_prime = [True] * (n+1)
is_prime[0] = False
is_prime[1] = False
judge = [i for i in range(n+1)]
for i in range(2, int(n**0.5) + 1):
if is_prime[i]:
for j in range(i*2, n+1, i):
is_prime[j] = False
judge[j] = i
return judge
n = int(eval(input()))
a = list(map(int, input().split()))
l = eratosthenes(10**6+1)
flag = True
used = [False] * (10**6+1)
for v in a:
while v > 1:
d = l[v]
if used[d]:
flag = False
else:
used[d] = True
while v % d == 0:
v //= d
if flag:
print('pairwise coprime')
exit()
g = a[0]
for v in a:
g = gcd(g, v)
print(('setwise coprime' if g == 1 else 'not coprime'))
|
from sys import exit
from math import gcd
def eratosthenes(n):
'''
n以下の整数の素数判定/列挙 (n > 1)
O(NloglogN)
'''
is_prime = [True] * (n+1)
is_prime[0] = False
is_prime[1] = False
min_factor = [-1] * (n+1)
min_factor[0] = 0
min_factor[1] = 1
for i in range(2, n+1):
if is_prime[i]:
min_factor[i] = i
for j in range(i*2, n+1, i):
is_prime[j] = False
if min_factor[j] == -1:
min_factor[j] = i
return min_factor
n = int(eval(input()))
a = list(map(int, input().split()))
l = eratosthenes(10**6+1)
flag = True
used = [False] * (10**6+1)
for v in a:
s = set()
while v > 1:
if l[v] not in s:
if used[l[v]]:
flag = False
break
else:
s.add(l[v])
used[l[v]] = True
v //= l[v]
if flag:
print('pairwise coprime')
exit()
g = 0
for v in a:
g = gcd(g, v)
print(('setwise coprime' if g == 1 else 'not coprime'))
| 50
| 55
| 934
| 1,113
|
from sys import exit
from math import gcd
def eratosthenes(n):
"""
n以下の整数の素数判定/列挙 (n > 1)
O(NloglogN)
"""
is_prime = [True] * (n + 1)
is_prime[0] = False
is_prime[1] = False
judge = [i for i in range(n + 1)]
for i in range(2, int(n**0.5) + 1):
if is_prime[i]:
for j in range(i * 2, n + 1, i):
is_prime[j] = False
judge[j] = i
return judge
n = int(eval(input()))
a = list(map(int, input().split()))
l = eratosthenes(10**6 + 1)
flag = True
used = [False] * (10**6 + 1)
for v in a:
while v > 1:
d = l[v]
if used[d]:
flag = False
else:
used[d] = True
while v % d == 0:
v //= d
if flag:
print("pairwise coprime")
exit()
g = a[0]
for v in a:
g = gcd(g, v)
print(("setwise coprime" if g == 1 else "not coprime"))
|
from sys import exit
from math import gcd
def eratosthenes(n):
"""
n以下の整数の素数判定/列挙 (n > 1)
O(NloglogN)
"""
is_prime = [True] * (n + 1)
is_prime[0] = False
is_prime[1] = False
min_factor = [-1] * (n + 1)
min_factor[0] = 0
min_factor[1] = 1
for i in range(2, n + 1):
if is_prime[i]:
min_factor[i] = i
for j in range(i * 2, n + 1, i):
is_prime[j] = False
if min_factor[j] == -1:
min_factor[j] = i
return min_factor
n = int(eval(input()))
a = list(map(int, input().split()))
l = eratosthenes(10**6 + 1)
flag = True
used = [False] * (10**6 + 1)
for v in a:
s = set()
while v > 1:
if l[v] not in s:
if used[l[v]]:
flag = False
break
else:
s.add(l[v])
used[l[v]] = True
v //= l[v]
if flag:
print("pairwise coprime")
exit()
g = 0
for v in a:
g = gcd(g, v)
print(("setwise coprime" if g == 1 else "not coprime"))
| false
| 9.090909
|
[
"- judge = [i for i in range(n + 1)]",
"- for i in range(2, int(n**0.5) + 1):",
"+ min_factor = [-1] * (n + 1)",
"+ min_factor[0] = 0",
"+ min_factor[1] = 1",
"+ for i in range(2, n + 1):",
"+ min_factor[i] = i",
"- judge[j] = i",
"- return judge",
"+ if min_factor[j] == -1:",
"+ min_factor[j] = i",
"+ return min_factor",
"+ s = set()",
"- d = l[v]",
"- if used[d]:",
"- flag = False",
"- else:",
"- used[d] = True",
"- while v % d == 0:",
"- v //= d",
"+ if l[v] not in s:",
"+ if used[l[v]]:",
"+ flag = False",
"+ break",
"+ else:",
"+ s.add(l[v])",
"+ used[l[v]] = True",
"+ v //= l[v]",
"-g = a[0]",
"+g = 0"
] | false
| 0.856463
| 1.271664
| 0.673498
|
[
"s792849070",
"s906532424"
] |
u070201429
|
p02839
|
python
|
s437644257
|
s684822108
| 922
| 776
| 249,340
| 222,088
|
Accepted
|
Accepted
| 15.84
|
def main():
from sys import stdin
def input():
return stdin.readline().strip()
h, w = list(map(int, input().split()))
g = []
for _ in range(h):
g.append(list(map(int, input().split())))
for i in range(h):
k = list(map(int, input().split()))
for j in range(w):
g[i][j] = abs(g[i][j] - k[j])
m = (h + w) * 50
if m == 0:
print((0))
exit()
dp = [[False] * m for _ in range(w)]
dp[0][g[0][0]] = True
for j in range(1, w):
for k in range(m):
if dp[j-1][k]:
dp[j][abs(k - g[0][j])] = True
try:
dp[j][k + g[0][j]] = True
except:
pass
for i in range(1, h):
new_dp = [[False] * m for _ in range(w)]
for k in range(m):
if dp[0][k]:
new_dp[0][abs(k - g[i][0])] = True
try:
new_dp[0][k + g[i][0]] = True
except:
pass
for j in range(1, w):
for k in range(m):
if new_dp[j-1][k] or dp[j][k]:
new_dp[j][abs(k - g[i][j])] = True
try:
new_dp[j][k + g[i][j]] = True
except:
pass
dp = new_dp
for j in range(m):
if dp[w-1][j]:
print(j)
break
main()
|
def main():
from sys import stdin
def input():
return stdin.readline().strip()
h, w = list(map(int, input().split()))
g = []
for _ in range(h):
g.append(list(map(int, input().split())))
for i in range(h):
k = list(map(int, input().split()))
for j in range(w):
g[i][j] = abs(g[i][j] - k[j])
m = (h + w) * 40
if m == 0:
print((0))
exit()
dp = [[False] * m for _ in range(w)]
dp[0][g[0][0]] = True
for j in range(1, w):
for k in range(m):
if dp[j-1][k]:
dp[j][abs(k - g[0][j])] = True
try:
dp[j][k + g[0][j]] = True
except:
pass
for i in range(1, h):
new_dp = [[False] * m for _ in range(w)]
for k in range(m):
if dp[0][k]:
new_dp[0][abs(k - g[i][0])] = True
try:
new_dp[0][k + g[i][0]] = True
except:
pass
for j in range(1, w):
for k in range(m):
if new_dp[j-1][k] or dp[j][k]:
new_dp[j][abs(k - g[i][j])] = True
try:
new_dp[j][k + g[i][j]] = True
except:
pass
dp = new_dp
for j in range(m):
if dp[w-1][j]:
print(j)
break
main()
| 57
| 57
| 1,514
| 1,514
|
def main():
from sys import stdin
def input():
return stdin.readline().strip()
h, w = list(map(int, input().split()))
g = []
for _ in range(h):
g.append(list(map(int, input().split())))
for i in range(h):
k = list(map(int, input().split()))
for j in range(w):
g[i][j] = abs(g[i][j] - k[j])
m = (h + w) * 50
if m == 0:
print((0))
exit()
dp = [[False] * m for _ in range(w)]
dp[0][g[0][0]] = True
for j in range(1, w):
for k in range(m):
if dp[j - 1][k]:
dp[j][abs(k - g[0][j])] = True
try:
dp[j][k + g[0][j]] = True
except:
pass
for i in range(1, h):
new_dp = [[False] * m for _ in range(w)]
for k in range(m):
if dp[0][k]:
new_dp[0][abs(k - g[i][0])] = True
try:
new_dp[0][k + g[i][0]] = True
except:
pass
for j in range(1, w):
for k in range(m):
if new_dp[j - 1][k] or dp[j][k]:
new_dp[j][abs(k - g[i][j])] = True
try:
new_dp[j][k + g[i][j]] = True
except:
pass
dp = new_dp
for j in range(m):
if dp[w - 1][j]:
print(j)
break
main()
|
def main():
from sys import stdin
def input():
return stdin.readline().strip()
h, w = list(map(int, input().split()))
g = []
for _ in range(h):
g.append(list(map(int, input().split())))
for i in range(h):
k = list(map(int, input().split()))
for j in range(w):
g[i][j] = abs(g[i][j] - k[j])
m = (h + w) * 40
if m == 0:
print((0))
exit()
dp = [[False] * m for _ in range(w)]
dp[0][g[0][0]] = True
for j in range(1, w):
for k in range(m):
if dp[j - 1][k]:
dp[j][abs(k - g[0][j])] = True
try:
dp[j][k + g[0][j]] = True
except:
pass
for i in range(1, h):
new_dp = [[False] * m for _ in range(w)]
for k in range(m):
if dp[0][k]:
new_dp[0][abs(k - g[i][0])] = True
try:
new_dp[0][k + g[i][0]] = True
except:
pass
for j in range(1, w):
for k in range(m):
if new_dp[j - 1][k] or dp[j][k]:
new_dp[j][abs(k - g[i][j])] = True
try:
new_dp[j][k + g[i][j]] = True
except:
pass
dp = new_dp
for j in range(m):
if dp[w - 1][j]:
print(j)
break
main()
| false
| 0
|
[
"- m = (h + w) * 50",
"+ m = (h + w) * 40"
] | false
| 0.047083
| 0.041358
| 1.13842
|
[
"s437644257",
"s684822108"
] |
u180914582
|
p02407
|
python
|
s410777818
|
s694558479
| 30
| 20
| 7,628
| 7,420
|
Accepted
|
Accepted
| 33.33
|
input()
i = list(map(int, input().split()))
i.reverse()
for j in range(len(i)) :
if j != 0 :
print(' ', end = '')
print(i[j], end = '')
print()
|
eval(input())
data = input().split()
data.reverse()
print((' '.join(data)))
| 8
| 4
| 166
| 70
|
input()
i = list(map(int, input().split()))
i.reverse()
for j in range(len(i)):
if j != 0:
print(" ", end="")
print(i[j], end="")
print()
|
eval(input())
data = input().split()
data.reverse()
print((" ".join(data)))
| false
| 50
|
[
"-input()",
"-i = list(map(int, input().split()))",
"-i.reverse()",
"-for j in range(len(i)):",
"- if j != 0:",
"- print(\" \", end=\"\")",
"- print(i[j], end=\"\")",
"-print()",
"+eval(input())",
"+data = input().split()",
"+data.reverse()",
"+print((\" \".join(data)))"
] | false
| 0.041904
| 0.044623
| 0.939071
|
[
"s410777818",
"s694558479"
] |
u762420987
|
p02762
|
python
|
s638872205
|
s261138227
| 856
| 788
| 90,712
| 14,192
|
Accepted
|
Accepted
| 7.94
|
import sys
input = sys.stdin.readline
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
self.group_count = n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
self.group_count -= 1
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def int_(num_str):
return int(num_str) - 1
N, M, K = list(map(int, input().split()))
uf = UnionFind(N)
some = [1] * N
for i in range(M):
a, b = list(map(int_, input().split()))
uf.union(a, b)
some[a] += 1
some[b] += 1
for i in range(K):
c, d = list(map(int_, input().split()))
if not uf.same(c, d):
pass
else:
some[c] += 1
some[d] += 1
ans = [uf.size(i) - some[i] for i in range(N)]
print((*ans))
|
import sys
input = sys.stdin.readline
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
self.group_count = n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
self.group_count -= 1
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def int_(num_str):
return int(num_str) - 1
N, M, K = list(map(int, input().split()))
uf = UnionFind(N)
some = [1] * N
for i in range(M):
a, b = list(map(int_, input().split()))
uf.union(a, b)
some[a] += 1
some[b] += 1
for i in range(K):
c, d = list(map(int_, input().split()))
if uf.same(c, d):
some[c] += 1
some[d] += 1
ans = [uf.size(i) - some[i] for i in range(N)]
print((*ans))
| 71
| 69
| 1,585
| 1,556
|
import sys
input = sys.stdin.readline
class UnionFind:
def __init__(self, n):
self.n = n
self.parents = [-1] * n
self.group_count = n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
self.group_count -= 1
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def int_(num_str):
return int(num_str) - 1
N, M, K = list(map(int, input().split()))
uf = UnionFind(N)
some = [1] * N
for i in range(M):
a, b = list(map(int_, input().split()))
uf.union(a, b)
some[a] += 1
some[b] += 1
for i in range(K):
c, d = list(map(int_, input().split()))
if not uf.same(c, d):
pass
else:
some[c] += 1
some[d] += 1
ans = [uf.size(i) - some[i] for i in range(N)]
print((*ans))
|
import sys
input = sys.stdin.readline
class UnionFind:
def __init__(self, n):
self.n = n
self.parents = [-1] * n
self.group_count = n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
self.group_count -= 1
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def int_(num_str):
return int(num_str) - 1
N, M, K = list(map(int, input().split()))
uf = UnionFind(N)
some = [1] * N
for i in range(M):
a, b = list(map(int_, input().split()))
uf.union(a, b)
some[a] += 1
some[b] += 1
for i in range(K):
c, d = list(map(int_, input().split()))
if uf.same(c, d):
some[c] += 1
some[d] += 1
ans = [uf.size(i) - some[i] for i in range(N)]
print((*ans))
| false
| 2.816901
|
[
"- if not uf.same(c, d):",
"- pass",
"- else:",
"+ if uf.same(c, d):"
] | false
| 0.039632
| 0.044034
| 0.900033
|
[
"s638872205",
"s261138227"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.