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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
u241159583
|
p04034
|
python
|
s813881928
|
s406164045
| 374 | 250 | 28,964 | 28,800 |
Accepted
|
Accepted
| 33.16 |
N, M = list(map(int, input().split()))
xy = [list(map(int, input().split())) for _ in range(M)]
red = [0] * (N+1) #赤になりうる場所を１とする
red[1] = 1
red[0] = ""
ball = [1] * (N+1) #個数
ball[0] = ""
for x, y in xy:
ball[y] += 1
ball[x] -= 1
if red[x] == 1:
red[y] = 1
if ball[x] == 0: red[x] = 0
print((red.count(1)))
|
n,m = list(map(int, input().split()))
xy = [list(map(int, input().split())) for _ in range(m)]
box = [1]*(n+1)
red = [0]*(n+1)
red[1] = 1
for x,y in xy:
box[x] -= 1
box[y] += 1
if red[x] == 1: red[y] = 1
if box[x] == 0: red[x] = 0
print((red.count(1)))
| 14 | 12 | 325 | 272 |
N, M = list(map(int, input().split()))
xy = [list(map(int, input().split())) for _ in range(M)]
red = [0] * (N + 1) # 赤になりうる場所を１とする
red[1] = 1
red[0] = ""
ball = [1] * (N + 1) # 個数
ball[0] = ""
for x, y in xy:
ball[y] += 1
ball[x] -= 1
if red[x] == 1:
red[y] = 1
if ball[x] == 0:
red[x] = 0
print((red.count(1)))
|
n, m = list(map(int, input().split()))
xy = [list(map(int, input().split())) for _ in range(m)]
box = [1] * (n + 1)
red = [0] * (n + 1)
red[1] = 1
for x, y in xy:
box[x] -= 1
box[y] += 1
if red[x] == 1:
red[y] = 1
if box[x] == 0:
red[x] = 0
print((red.count(1)))
| false | 14.285714 |
[
"-N, M = list(map(int, input().split()))",
"-xy = [list(map(int, input().split())) for _ in range(M)]",
"-red = [0] * (N + 1) # 赤になりうる場所を１とする",
"+n, m = list(map(int, input().split()))",
"+xy = [list(map(int, input().split())) for _ in range(m)]",
"+box = [1] * (n + 1)",
"+red = [0] * (n + 1)",
"-red[0] = \"\"",
"-ball = [1] * (N + 1) # 個数",
"-ball[0] = \"\"",
"- ball[y] += 1",
"- ball[x] -= 1",
"+ box[x] -= 1",
"+ box[y] += 1",
"- if ball[x] == 0:",
"- red[x] = 0",
"+ if box[x] == 0:",
"+ red[x] = 0"
] | false | 0.047013 | 0.144159 | 0.326122 |
[
"s813881928",
"s406164045"
] |
u272028993
|
p03894
|
python
|
s788810560
|
s415207218
| 360 | 325 | 5,764 | 6,660 |
Accepted
|
Accepted
| 9.72 |
n,q=list(map(int,input().split()))
exist=set([1])
cup=list(range(n+2))
now=1
exist.add(cup[now-1])
exist.add(cup[now+1])
for i in range(q):
a,b=list(map(int,input().split()))
if now==a:now=b
elif now==b:now=a
tmp=cup[a]
cup[a]=cup[b]
cup[b]=tmp
exist.add(cup[now-1])
exist.add(cup[now+1])
exist=list(exist)
ans=0
for i in range(len(exist)):
if exist[i]!=0 and exist[i]!=n+1:ans+=1
print(ans)
|
n,q=list(map(int,input().split()))
exist=[False]*(n+2)
exist[1]=True
cup=list(range(n+2))
now=1
exist[cup[now-1]]=True
exist[cup[now+1]]=True
for i in range(q):
a,b=list(map(int,input().split()))
if now==a:now=b
elif now==b:now=a
tmp=cup[a]
cup[a]=cup[b]
cup[b]=tmp
exist[cup[now-1]]=True
exist[cup[now+1]]=True
ans=0
for i in range(1,n+1):
if exist[i]:ans+=1
print(ans)
| 20 | 20 | 437 | 417 |
n, q = list(map(int, input().split()))
exist = set([1])
cup = list(range(n + 2))
now = 1
exist.add(cup[now - 1])
exist.add(cup[now + 1])
for i in range(q):
a, b = list(map(int, input().split()))
if now == a:
now = b
elif now == b:
now = a
tmp = cup[a]
cup[a] = cup[b]
cup[b] = tmp
exist.add(cup[now - 1])
exist.add(cup[now + 1])
exist = list(exist)
ans = 0
for i in range(len(exist)):
if exist[i] != 0 and exist[i] != n + 1:
ans += 1
print(ans)
|
n, q = list(map(int, input().split()))
exist = [False] * (n + 2)
exist[1] = True
cup = list(range(n + 2))
now = 1
exist[cup[now - 1]] = True
exist[cup[now + 1]] = True
for i in range(q):
a, b = list(map(int, input().split()))
if now == a:
now = b
elif now == b:
now = a
tmp = cup[a]
cup[a] = cup[b]
cup[b] = tmp
exist[cup[now - 1]] = True
exist[cup[now + 1]] = True
ans = 0
for i in range(1, n + 1):
if exist[i]:
ans += 1
print(ans)
| false | 0 |
[
"-exist = set([1])",
"+exist = [False] * (n + 2)",
"+exist[1] = True",
"-exist.add(cup[now - 1])",
"-exist.add(cup[now + 1])",
"+exist[cup[now - 1]] = True",
"+exist[cup[now + 1]] = True",
"- exist.add(cup[now - 1])",
"- exist.add(cup[now + 1])",
"-exist = list(exist)",
"+ exist[cup[now - 1]] = True",
"+ exist[cup[now + 1]] = True",
"-for i in range(len(exist)):",
"- if exist[i] != 0 and exist[i] != n + 1:",
"+for i in range(1, n + 1):",
"+ if exist[i]:"
] | false | 0.038277 | 0.037587 | 1.018363 |
[
"s788810560",
"s415207218"
] |
u254871849
|
p03721
|
python
|
s255280798
|
s773269506
| 323 | 167 | 5,848 | 5,744 |
Accepted
|
Accepted
| 48.3 |
N, K = [int(x) for x in input().split()]
arr = [0] * (10**5+1)
for _ in range(N):
a, b = [int(x) for x in input().split()]
arr[a] += b
remain = K
for i in range(1, 10**5+1):
if arr[i] != 0:
remain -= arr[i]
if remain <= 0:
print(i)
exit()
|
import sys
input = sys.stdin.readline
N, K = [int(x) for x in input().split()]
arr = [0] * (10**5+1)
for _ in range(N):
a, b = [int(x) for x in input().split()]
arr[a] += b
remain = K
for i in range(1, 10**5+1):
if arr[i] != 0:
remain -= arr[i]
if remain <= 0:
print(i)
exit()
| 13 | 16 | 291 | 333 |
N, K = [int(x) for x in input().split()]
arr = [0] * (10**5 + 1)
for _ in range(N):
a, b = [int(x) for x in input().split()]
arr[a] += b
remain = K
for i in range(1, 10**5 + 1):
if arr[i] != 0:
remain -= arr[i]
if remain <= 0:
print(i)
exit()
|
import sys
input = sys.stdin.readline
N, K = [int(x) for x in input().split()]
arr = [0] * (10**5 + 1)
for _ in range(N):
a, b = [int(x) for x in input().split()]
arr[a] += b
remain = K
for i in range(1, 10**5 + 1):
if arr[i] != 0:
remain -= arr[i]
if remain <= 0:
print(i)
exit()
| false | 18.75 |
[
"+import sys",
"+",
"+input = sys.stdin.readline"
] | false | 0.05003 | 0.092587 | 0.540357 |
[
"s255280798",
"s773269506"
] |
u777299405
|
p02257
|
python
|
s342514540
|
s574858950
| 560 | 360 | 6,724 | 6,808 |
Accepted
|
Accepted
| 35.71 |
def isprime(n):
if n == 2:
return True
if n % 2 == 0:
return False
i = 3
while i * i <= n:
if n % i == 0:
return False
i += 2
return True
result = 0
for i in range(int(eval(input()))):
result += isprime(int(eval(input())))
print(result)
|
from math import sqrt
def isprime(n):
if n == 2:
return True
if n % 2 == 0:
return False
for i in range(3, int(sqrt(n)) + 1, 2):
if n % i == 0:
return False
return True
result = 0
for i in range(int(eval(input()))):
result += isprime(int(eval(input())))
print(result)
| 16 | 17 | 308 | 330 |
def isprime(n):
if n == 2:
return True
if n % 2 == 0:
return False
i = 3
while i * i <= n:
if n % i == 0:
return False
i += 2
return True
result = 0
for i in range(int(eval(input()))):
result += isprime(int(eval(input())))
print(result)
|
from math import sqrt
def isprime(n):
if n == 2:
return True
if n % 2 == 0:
return False
for i in range(3, int(sqrt(n)) + 1, 2):
if n % i == 0:
return False
return True
result = 0
for i in range(int(eval(input()))):
result += isprime(int(eval(input())))
print(result)
| false | 5.882353 |
[
"+from math import sqrt",
"+",
"+",
"- i = 3",
"- while i * i <= n:",
"+ for i in range(3, int(sqrt(n)) + 1, 2):",
"- i += 2"
] | false | 0.160795 | 0.043772 | 3.673461 |
[
"s342514540",
"s574858950"
] |
u094999522
|
p03221
|
python
|
s696965445
|
s011279044
| 608 | 365 | 82,720 | 75,648 |
Accepted
|
Accepted
| 39.97 |
#!/usr/bin/env python3
(n, m), *q = [[*list(map(int, i.split()))] for i in open(0)]
s = sorted(q)
d = {}
for k, v in s:
if k not in d:
d[k] = []
d[k].append(v)
c = {}
for k, v in list(d.items()):
i = 0
if k not in c:
c[k] = {}
while i < len(v):
i += 1
c[k][v[~-i]] = str(i)
for p, y in q:
pn = "00000" + str(p)
cn = "00000" + c[p][y]
print((pn[-6:] + cn[-6:]))
|
from collections import defaultdict
(n, m), *q = [[*list(map(int, i.split()))] for i in open(0)]
d = defaultdict(list)
for k, v in q:
d[k].append(v)
c = defaultdict(dict)
for k, v in list(d.items()):
for i, j in enumerate(sorted(v)):
c[k][j] = i + 1
for p, y in q:
print(("{:0>6}{:0>6}".format(p, c[p][y])))
| 20 | 11 | 430 | 324 |
#!/usr/bin/env python3
(n, m), *q = [[*list(map(int, i.split()))] for i in open(0)]
s = sorted(q)
d = {}
for k, v in s:
if k not in d:
d[k] = []
d[k].append(v)
c = {}
for k, v in list(d.items()):
i = 0
if k not in c:
c[k] = {}
while i < len(v):
i += 1
c[k][v[~-i]] = str(i)
for p, y in q:
pn = "00000" + str(p)
cn = "00000" + c[p][y]
print((pn[-6:] + cn[-6:]))
|
from collections import defaultdict
(n, m), *q = [[*list(map(int, i.split()))] for i in open(0)]
d = defaultdict(list)
for k, v in q:
d[k].append(v)
c = defaultdict(dict)
for k, v in list(d.items()):
for i, j in enumerate(sorted(v)):
c[k][j] = i + 1
for p, y in q:
print(("{:0>6}{:0>6}".format(p, c[p][y])))
| false | 45 |
[
"-#!/usr/bin/env python3",
"+from collections import defaultdict",
"+",
"-s = sorted(q)",
"-d = {}",
"-for k, v in s:",
"- if k not in d:",
"- d[k] = []",
"+d = defaultdict(list)",
"+for k, v in q:",
"-c = {}",
"+c = defaultdict(dict)",
"- i = 0",
"- if k not in c:",
"- c[k] = {}",
"- while i < len(v):",
"- i += 1",
"- c[k][v[~-i]] = str(i)",
"+ for i, j in enumerate(sorted(v)):",
"+ c[k][j] = i + 1",
"- pn = \"00000\" + str(p)",
"- cn = \"00000\" + c[p][y]",
"- print((pn[-6:] + cn[-6:]))",
"+ print((\"{:0>6}{:0>6}\".format(p, c[p][y])))"
] | false | 0.038022 | 0.037254 | 1.020613 |
[
"s696965445",
"s011279044"
] |
u352394527
|
p00042
|
python
|
s170572248
|
s545275817
| 510 | 380 | 5,656 | 5,644 |
Accepted
|
Accepted
| 25.49 |
"""
0-1ナップザック
wi = wlst[i]...i個目の重さ
vi = vlst[i]...i個目の価値
2次元
dp[i][j]...i個目までの宝で重さjの時の価値の最大
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - wi] + vi) (wi <= j)
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]) (wi > j)
or
dp[j]...重さjの時の価値の最大
temp...1つ前のdp
dp[j] = max(dp[j], dp[j - 1], temp[j - wi] + vi) (wi <= j)
dp[j] = max(dp[j], dp[j - 1]) (wi > j)
"""
INF = 10 ** 20
def main():
case = 0
while True:
w = int(eval(input()))
if not w:
break
case += 1
n = int(eval(input()))
vlst = [0]
wlst = [0]
for _ in range(n):
vin, win = list(map(int, input().split(",")))
vlst.append(vin)
wlst.append(win)
dp = [0 for _ in range(w + 1)]
for i in range(1, n + 1):
vi, wi = vlst[i], wlst[i]
temp = dp[:]
for j in range(1, w + 1):
if j >= wi:
dp[j] = max(dp[j], dp[j - 1], temp[j - wi] + vi)
else:
dp[j] = max(dp[j], dp[j - 1])
print(("Case " + str(case) + ":"))
print((dp[w]))
print((dp.index(dp[w])))
main()
|
"""
0-1ナップザック
wi...i個目の重さ
vi...i個目の価値
2次元
dp[i][j]...i個目までの宝で重さjの時の価値の最大
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - wi] + vi) (wi <= j)
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]) (wi > j)
1次元
dp[j]...重さjの時の価値の最大
dp[j] = max(dp[j], dp[j - wi] + vi) (wi <= j <= w)
wi <= j <= wについて更新(j < wiについては変化が無いため更新不要)
前から更新すると更新した結果を使って更新してしまうため後ろから更新
"""
INF = 10 ** 20
def main():
case = 0
while True:
w = int(eval(input()))
if not w:
break
case += 1
n = int(eval(input()))
dp = [0 for _ in range(w + 1)]
for i in range(1, n + 1):
vi, wi = list(map(int, input().split(",")))
for j in range(w, wi - 1, -1):
dp[j] = max(dp[j], dp[j - wi] + vi)
print(("Case " + str(case) + ":"))
print((dp[w]))
print((dp.index(dp[w])))
main()
| 58 | 47 | 1,145 | 871 |
"""
0-1ナップザック
wi = wlst[i]...i個目の重さ
vi = vlst[i]...i個目の価値
2次元
dp[i][j]...i個目までの宝で重さjの時の価値の最大
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - wi] + vi) (wi <= j)
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]) (wi > j)
or
dp[j]...重さjの時の価値の最大
temp...1つ前のdp
dp[j] = max(dp[j], dp[j - 1], temp[j - wi] + vi) (wi <= j)
dp[j] = max(dp[j], dp[j - 1]) (wi > j)
"""
INF = 10**20
def main():
case = 0
while True:
w = int(eval(input()))
if not w:
break
case += 1
n = int(eval(input()))
vlst = [0]
wlst = [0]
for _ in range(n):
vin, win = list(map(int, input().split(",")))
vlst.append(vin)
wlst.append(win)
dp = [0 for _ in range(w + 1)]
for i in range(1, n + 1):
vi, wi = vlst[i], wlst[i]
temp = dp[:]
for j in range(1, w + 1):
if j >= wi:
dp[j] = max(dp[j], dp[j - 1], temp[j - wi] + vi)
else:
dp[j] = max(dp[j], dp[j - 1])
print(("Case " + str(case) + ":"))
print((dp[w]))
print((dp.index(dp[w])))
main()
|
"""
0-1ナップザック
wi...i個目の重さ
vi...i個目の価値
2次元
dp[i][j]...i個目までの宝で重さjの時の価値の最大
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - wi] + vi) (wi <= j)
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]) (wi > j)
1次元
dp[j]...重さjの時の価値の最大
dp[j] = max(dp[j], dp[j - wi] + vi) (wi <= j <= w)
wi <= j <= wについて更新(j < wiについては変化が無いため更新不要)
前から更新すると更新した結果を使って更新してしまうため後ろから更新
"""
INF = 10**20
def main():
case = 0
while True:
w = int(eval(input()))
if not w:
break
case += 1
n = int(eval(input()))
dp = [0 for _ in range(w + 1)]
for i in range(1, n + 1):
vi, wi = list(map(int, input().split(",")))
for j in range(w, wi - 1, -1):
dp[j] = max(dp[j], dp[j - wi] + vi)
print(("Case " + str(case) + ":"))
print((dp[w]))
print((dp.index(dp[w])))
main()
| false | 18.965517 |
[
"-wi = wlst[i]...i個目の重さ",
"-vi = vlst[i]...i個目の価値",
"+wi...i個目の重さ",
"+vi...i個目の価値",
"-or",
"+1次元",
"-temp...1つ前のdp",
"-dp[j] = max(dp[j], dp[j - 1], temp[j - wi] + vi) (wi <= j)",
"-dp[j] = max(dp[j], dp[j - 1]) (wi > j)",
"+dp[j] = max(dp[j], dp[j - wi] + vi) (wi <= j <= w)",
"+wi <= j <= wについて更新(j < wiについては変化が無いため更新不要)",
"+前から更新すると更新した結果を使って更新してしまうため後ろから更新",
"- vlst = [0]",
"- wlst = [0]",
"- for _ in range(n):",
"- vin, win = list(map(int, input().split(\",\")))",
"- vlst.append(vin)",
"- wlst.append(win)",
"- vi, wi = vlst[i], wlst[i]",
"- temp = dp[:]",
"- for j in range(1, w + 1):",
"- if j >= wi:",
"- dp[j] = max(dp[j], dp[j - 1], temp[j - wi] + vi)",
"- else:",
"- dp[j] = max(dp[j], dp[j - 1])",
"+ vi, wi = list(map(int, input().split(\",\")))",
"+ for j in range(w, wi - 1, -1):",
"+ dp[j] = max(dp[j], dp[j - wi] + vi)"
] | false | 0.060684 | 0.036917 | 1.643786 |
[
"s170572248",
"s545275817"
] |
u312025627
|
p02862
|
python
|
s648649401
|
s574845774
| 394 | 98 | 85,488 | 79,768 |
Accepted
|
Accepted
| 75.13 |
def main():
X, Y = (int(i) for i in input().split())
if (X+Y) % 3 != 0:
return print(0)
MOD = 10**9 + 7
m = X + Y + 5
fac = [0] * m
finv = [0] * m
inv = [0] * m
def COMBinitialize(m):
fac[0] = 1
finv[0] = 1
if m > 1:
fac[1] = 1
finv[1] = 1
inv[1] = 1
for i in range(2, m):
fac[i] = fac[i-1] * i % MOD
inv[i] = MOD - inv[MOD % i] * (MOD // i) % MOD
finv[i] = finv[i - 1] * inv[i] % MOD
def COMB(n, k):
if n < k:
return 0
if n < 0 or k < 0:
return 0
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD
COMBinitialize(m)
n = (X+Y)//3
r = X - n
print(COMB(n, r))
if __name__ == '__main__':
main()
|
MOD = 10**9 + 7
m = 666666 + 500
fac = [0] * m
finv = [0] * m
inv = [0] * m
def COMBinitialize(m):
fac[0] = 1
finv[0] = 1
if m > 1:
fac[1] = 1
finv[1] = 1
inv[1] = 1
for i in range(2, m):
fac[i] = fac[i-1] * i % MOD
inv[i] = MOD - inv[MOD % i] * (MOD // i) % MOD
finv[i] = finv[i - 1] * inv[i] % MOD
def COMB(n, k):
if n < k:
return 0
if n < 0 or k < 0:
return 0
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD
COMBinitialize(m)
def main():
X, Y = (int(i) for i in input().split())
if (X+Y) % 3 != 0:
return print(0)
ans = COMB((X+Y)//3, X - (X+Y)//3)
print(ans)
if __name__ == '__main__':
main()
| 38 | 41 | 868 | 787 |
def main():
X, Y = (int(i) for i in input().split())
if (X + Y) % 3 != 0:
return print(0)
MOD = 10**9 + 7
m = X + Y + 5
fac = [0] * m
finv = [0] * m
inv = [0] * m
def COMBinitialize(m):
fac[0] = 1
finv[0] = 1
if m > 1:
fac[1] = 1
finv[1] = 1
inv[1] = 1
for i in range(2, m):
fac[i] = fac[i - 1] * i % MOD
inv[i] = MOD - inv[MOD % i] * (MOD // i) % MOD
finv[i] = finv[i - 1] * inv[i] % MOD
def COMB(n, k):
if n < k:
return 0
if n < 0 or k < 0:
return 0
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD
COMBinitialize(m)
n = (X + Y) // 3
r = X - n
print(COMB(n, r))
if __name__ == "__main__":
main()
|
MOD = 10**9 + 7
m = 666666 + 500
fac = [0] * m
finv = [0] * m
inv = [0] * m
def COMBinitialize(m):
fac[0] = 1
finv[0] = 1
if m > 1:
fac[1] = 1
finv[1] = 1
inv[1] = 1
for i in range(2, m):
fac[i] = fac[i - 1] * i % MOD
inv[i] = MOD - inv[MOD % i] * (MOD // i) % MOD
finv[i] = finv[i - 1] * inv[i] % MOD
def COMB(n, k):
if n < k:
return 0
if n < 0 or k < 0:
return 0
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD
COMBinitialize(m)
def main():
X, Y = (int(i) for i in input().split())
if (X + Y) % 3 != 0:
return print(0)
ans = COMB((X + Y) // 3, X - (X + Y) // 3)
print(ans)
if __name__ == "__main__":
main()
| false | 7.317073 |
[
"+MOD = 10**9 + 7",
"+m = 666666 + 500",
"+fac = [0] * m",
"+finv = [0] * m",
"+inv = [0] * m",
"+",
"+",
"+def COMBinitialize(m):",
"+ fac[0] = 1",
"+ finv[0] = 1",
"+ if m > 1:",
"+ fac[1] = 1",
"+ finv[1] = 1",
"+ inv[1] = 1",
"+ for i in range(2, m):",
"+ fac[i] = fac[i - 1] * i % MOD",
"+ inv[i] = MOD - inv[MOD % i] * (MOD // i) % MOD",
"+ finv[i] = finv[i - 1] * inv[i] % MOD",
"+",
"+",
"+def COMB(n, k):",
"+ if n < k:",
"+ return 0",
"+ if n < 0 or k < 0:",
"+ return 0",
"+ return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD",
"+",
"+",
"+COMBinitialize(m)",
"+",
"+",
"- MOD = 10**9 + 7",
"- m = X + Y + 5",
"- fac = [0] * m",
"- finv = [0] * m",
"- inv = [0] * m",
"-",
"- def COMBinitialize(m):",
"- fac[0] = 1",
"- finv[0] = 1",
"- if m > 1:",
"- fac[1] = 1",
"- finv[1] = 1",
"- inv[1] = 1",
"- for i in range(2, m):",
"- fac[i] = fac[i - 1] * i % MOD",
"- inv[i] = MOD - inv[MOD % i] * (MOD // i) % MOD",
"- finv[i] = finv[i - 1] * inv[i] % MOD",
"-",
"- def COMB(n, k):",
"- if n < k:",
"- return 0",
"- if n < 0 or k < 0:",
"- return 0",
"- return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD",
"-",
"- COMBinitialize(m)",
"- n = (X + Y) // 3",
"- r = X - n",
"- print(COMB(n, r))",
"+ ans = COMB((X + Y) // 3, X - (X + Y) // 3)",
"+ print(ans)"
] | false | 0.971233 | 1.503631 | 0.645925 |
[
"s648649401",
"s574845774"
] |
u672475305
|
p03476
|
python
|
s249607698
|
s306277022
| 1,063 | 686 | 56,772 | 9,748 |
Accepted
|
Accepted
| 35.47 |
import math
def eratosthenes(n):
prime = []
limit = math.sqrt(n)
data = [i+1 for i in range(1,n)]
while True:
p = data[0]
if limit <= p:
return prime + data
prime.append(p)
data = [e for e in data if e%p != 0]
_primes = eratosthenes(10**5)
primes = [False] * (10**5+1)
for p in _primes:
primes[p] = True
like_2017 = [False] * (10**5+1)
for p in _primes:
if primes[(p+1)//2]:
like_2017[p] = True
c = 0
C = [0]
for i in range(1,10**5+1):
if like_2017[i]:
c += 1
C.append(c)
q = int(eval(input()))
for _ in range(q):
l,r = list(map(int,input().split()))
print((C[r] - C[l-1]))
|
import bisect
def is_prime(x):
if x==1:
return False
for i in range(2,int(x**0.5)+1):
if x%i==0:
return False
return True
lst = []
for x in range(1,10**5,2):
if is_prime(x):
lst.append(x)
lst_dash = []
for x in lst:
if is_prime((x+1)//2):
lst_dash.append(x)
q = int(input())
ans = []
for i in range(q):
l,r = map(int,input().split())
left = bisect.bisect_left(lst_dash, l)
right = bisect.bisect_right(lst_dash, r)
ans.append(right - left)
print(*ans, sep='\n')
| 35 | 29 | 699 | 574 |
import math
def eratosthenes(n):
prime = []
limit = math.sqrt(n)
data = [i + 1 for i in range(1, n)]
while True:
p = data[0]
if limit <= p:
return prime + data
prime.append(p)
data = [e for e in data if e % p != 0]
_primes = eratosthenes(10**5)
primes = [False] * (10**5 + 1)
for p in _primes:
primes[p] = True
like_2017 = [False] * (10**5 + 1)
for p in _primes:
if primes[(p + 1) // 2]:
like_2017[p] = True
c = 0
C = [0]
for i in range(1, 10**5 + 1):
if like_2017[i]:
c += 1
C.append(c)
q = int(eval(input()))
for _ in range(q):
l, r = list(map(int, input().split()))
print((C[r] - C[l - 1]))
|
import bisect
def is_prime(x):
if x == 1:
return False
for i in range(2, int(x**0.5) + 1):
if x % i == 0:
return False
return True
lst = []
for x in range(1, 10**5, 2):
if is_prime(x):
lst.append(x)
lst_dash = []
for x in lst:
if is_prime((x + 1) // 2):
lst_dash.append(x)
q = int(input())
ans = []
for i in range(q):
l, r = map(int, input().split())
left = bisect.bisect_left(lst_dash, l)
right = bisect.bisect_right(lst_dash, r)
ans.append(right - left)
print(*ans, sep="\n")
| false | 17.142857 |
[
"-import math",
"+import bisect",
"-def eratosthenes(n):",
"- prime = []",
"- limit = math.sqrt(n)",
"- data = [i + 1 for i in range(1, n)]",
"- while True:",
"- p = data[0]",
"- if limit <= p:",
"- return prime + data",
"- prime.append(p)",
"- data = [e for e in data if e % p != 0]",
"+def is_prime(x):",
"+ if x == 1:",
"+ return False",
"+ for i in range(2, int(x**0.5) + 1):",
"+ if x % i == 0:",
"+ return False",
"+ return True",
"-_primes = eratosthenes(10**5)",
"-primes = [False] * (10**5 + 1)",
"-for p in _primes:",
"- primes[p] = True",
"-like_2017 = [False] * (10**5 + 1)",
"-for p in _primes:",
"- if primes[(p + 1) // 2]:",
"- like_2017[p] = True",
"-c = 0",
"-C = [0]",
"-for i in range(1, 10**5 + 1):",
"- if like_2017[i]:",
"- c += 1",
"- C.append(c)",
"-q = int(eval(input()))",
"-for _ in range(q):",
"- l, r = list(map(int, input().split()))",
"- print((C[r] - C[l - 1]))",
"+lst = []",
"+for x in range(1, 10**5, 2):",
"+ if is_prime(x):",
"+ lst.append(x)",
"+lst_dash = []",
"+for x in lst:",
"+ if is_prime((x + 1) // 2):",
"+ lst_dash.append(x)",
"+q = int(input())",
"+ans = []",
"+for i in range(q):",
"+ l, r = map(int, input().split())",
"+ left = bisect.bisect_left(lst_dash, l)",
"+ right = bisect.bisect_right(lst_dash, r)",
"+ ans.append(right - left)",
"+print(*ans, sep=\"\\n\")"
] | false | 0.174638 | 0.340198 | 0.513341 |
[
"s249607698",
"s306277022"
] |
u883048396
|
p03244
|
python
|
s000131795
|
s179534649
| 95 | 87 | 17,568 | 20,700 |
Accepted
|
Accepted
| 8.42 |
iN = int(eval(input()))
aV = [int(_) for _ in input().split()]
aV0={}
aV1={}
for i in range(iN):
iA = aV[i]
if i % 2 == 0:
if iA in aV0:
aV0[iA] += 1
else:
aV0[iA] = 1
else:
if iA in aV1:
aV1[iA] += 1
else:
aV1[iA] = 1
aV0[0]=0
aV1[0]=0
aV0dec = sorted(aV0,key=aV0.get,reverse=True)
aV1dec = sorted(aV1,key=aV1.get,reverse=True)
iMax1aV0 = aV0dec[0]
iMax1aV1 = aV1dec[0]
if iMax1aV0 != iMax1aV1:
print((iN - aV0[iMax1aV0] - aV1[iMax1aV1]))
else:
print((iN - max(aV0[iMax1aV0],aV1[iMax1aV1]) - max(aV0[aV0dec[1]],aV1[aV1dec[1]])))
|
from collections import Counter
iN = int(eval(input()))
aV = [int(_) for _ in input().split()]
oV0 = Counter(aV[0::2]).most_common()
oV1 = Counter(aV[1::2]).most_common()
oV0 += [(0,0)]
oV1 += [(0,0)]
if oV0[0][0] != oV1[0][0] :
print((iN - oV0[0][1] - oV1[0][1]))
else:
print((iN - max(oV0[0][1],oV1[0][1]) - max(oV0[1][1],oV1[1][1])))
| 30 | 14 | 653 | 351 |
iN = int(eval(input()))
aV = [int(_) for _ in input().split()]
aV0 = {}
aV1 = {}
for i in range(iN):
iA = aV[i]
if i % 2 == 0:
if iA in aV0:
aV0[iA] += 1
else:
aV0[iA] = 1
else:
if iA in aV1:
aV1[iA] += 1
else:
aV1[iA] = 1
aV0[0] = 0
aV1[0] = 0
aV0dec = sorted(aV0, key=aV0.get, reverse=True)
aV1dec = sorted(aV1, key=aV1.get, reverse=True)
iMax1aV0 = aV0dec[0]
iMax1aV1 = aV1dec[0]
if iMax1aV0 != iMax1aV1:
print((iN - aV0[iMax1aV0] - aV1[iMax1aV1]))
else:
print(
(iN - max(aV0[iMax1aV0], aV1[iMax1aV1]) - max(aV0[aV0dec[1]], aV1[aV1dec[1]]))
)
|
from collections import Counter
iN = int(eval(input()))
aV = [int(_) for _ in input().split()]
oV0 = Counter(aV[0::2]).most_common()
oV1 = Counter(aV[1::2]).most_common()
oV0 += [(0, 0)]
oV1 += [(0, 0)]
if oV0[0][0] != oV1[0][0]:
print((iN - oV0[0][1] - oV1[0][1]))
else:
print((iN - max(oV0[0][1], oV1[0][1]) - max(oV0[1][1], oV1[1][1])))
| false | 53.333333 |
[
"+from collections import Counter",
"+",
"-aV0 = {}",
"-aV1 = {}",
"-for i in range(iN):",
"- iA = aV[i]",
"- if i % 2 == 0:",
"- if iA in aV0:",
"- aV0[iA] += 1",
"- else:",
"- aV0[iA] = 1",
"- else:",
"- if iA in aV1:",
"- aV1[iA] += 1",
"- else:",
"- aV1[iA] = 1",
"-aV0[0] = 0",
"-aV1[0] = 0",
"-aV0dec = sorted(aV0, key=aV0.get, reverse=True)",
"-aV1dec = sorted(aV1, key=aV1.get, reverse=True)",
"-iMax1aV0 = aV0dec[0]",
"-iMax1aV1 = aV1dec[0]",
"-if iMax1aV0 != iMax1aV1:",
"- print((iN - aV0[iMax1aV0] - aV1[iMax1aV1]))",
"+oV0 = Counter(aV[0::2]).most_common()",
"+oV1 = Counter(aV[1::2]).most_common()",
"+oV0 += [(0, 0)]",
"+oV1 += [(0, 0)]",
"+if oV0[0][0] != oV1[0][0]:",
"+ print((iN - oV0[0][1] - oV1[0][1]))",
"- print(",
"- (iN - max(aV0[iMax1aV0], aV1[iMax1aV1]) - max(aV0[aV0dec[1]], aV1[aV1dec[1]]))",
"- )",
"+ print((iN - max(oV0[0][1], oV1[0][1]) - max(oV0[1][1], oV1[1][1])))"
] | false | 0.048787 | 0.007017 | 6.953115 |
[
"s000131795",
"s179534649"
] |
u634079249
|
p03796
|
python
|
s844647459
|
s155550438
| 231 | 155 | 4,208 | 10,444 |
Accepted
|
Accepted
| 32.9 |
import sys
import os
import math
MOD = 1000000007
def main():
if os.getenv("LOCAL"):
sys.stdin = open("input.txt", "r")
N = int(sys.stdin.readline().rstrip())
print((math.factorial(N) % MOD))
if __name__ == '__main__':
main()
|
import sys
import os
import math
import bisect
import collections
import itertools
import heapq
ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]
iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]
lcm = lambda x, y: x * y / math.gcd(x, y)
MOD = 10 ** 9 + 7
MAX = float('inf')
def main():
if os.getenv("LOCAL"):
sys.stdin = open("input.txt", "r")
N = ii()
print((math.factorial(N)%MOD))
if __name__ == '__main__':
main()
| 17 | 33 | 270 | 863 |
import sys
import os
import math
MOD = 1000000007
def main():
if os.getenv("LOCAL"):
sys.stdin = open("input.txt", "r")
N = int(sys.stdin.readline().rstrip())
print((math.factorial(N) % MOD))
if __name__ == "__main__":
main()
|
import sys
import os
import math
import bisect
import collections
import itertools
import heapq
ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]
iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]
lcm = lambda x, y: x * y / math.gcd(x, y)
MOD = 10**9 + 7
MAX = float("inf")
def main():
if os.getenv("LOCAL"):
sys.stdin = open("input.txt", "r")
N = ii()
print((math.factorial(N) % MOD))
if __name__ == "__main__":
main()
| false | 48.484848 |
[
"+import bisect",
"+import collections",
"+import itertools",
"+import heapq",
"-MOD = 1000000007",
"+ii = lambda: int(sys.stdin.buffer.readline().rstrip())",
"+il = lambda: list(map(int, sys.stdin.buffer.readline().split()))",
"+fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))",
"+iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]",
"+iss = lambda: sys.stdin.buffer.readline().decode().rstrip()",
"+sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))",
"+isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]",
"+lcm = lambda x, y: x * y / math.gcd(x, y)",
"+MOD = 10**9 + 7",
"+MAX = float(\"inf\")",
"- N = int(sys.stdin.readline().rstrip())",
"+ N = ii()"
] | false | 0.21094 | 0.276747 | 0.762211 |
[
"s844647459",
"s155550438"
] |
u174831560
|
p02640
|
python
|
s961289719
|
s599626802
| 25 | 20 | 9,192 | 9,088 |
Accepted
|
Accepted
| 20 |
def main():
c = eval(input())
c = c.split(' ')
x = int(c[0])
y = int(c[1])
for i in range(0, 100):
turu = i * 2
for j in range(0, 100):
kame = j * 4
if turu + kame == y and i + j == x:
print('Yes')
return
print('No')
if __name__ == "__main__":
main()
|
c = eval(input())
c = c.split(' ')
x = int(c[0])
y = int(c[1])
sa = 4 * x -y
if sa % 2 == 0 and x*2 <= y and x*4>=y:
print('Yes')
else:
print('No')
| 17 | 9 | 314 | 153 |
def main():
c = eval(input())
c = c.split(" ")
x = int(c[0])
y = int(c[1])
for i in range(0, 100):
turu = i * 2
for j in range(0, 100):
kame = j * 4
if turu + kame == y and i + j == x:
print("Yes")
return
print("No")
if __name__ == "__main__":
main()
|
c = eval(input())
c = c.split(" ")
x = int(c[0])
y = int(c[1])
sa = 4 * x - y
if sa % 2 == 0 and x * 2 <= y and x * 4 >= y:
print("Yes")
else:
print("No")
| false | 47.058824 |
[
"-def main():",
"- c = eval(input())",
"- c = c.split(\" \")",
"- x = int(c[0])",
"- y = int(c[1])",
"- for i in range(0, 100):",
"- turu = i * 2",
"- for j in range(0, 100):",
"- kame = j * 4",
"- if turu + kame == y and i + j == x:",
"- print(\"Yes\")",
"- return",
"+c = eval(input())",
"+c = c.split(\" \")",
"+x = int(c[0])",
"+y = int(c[1])",
"+sa = 4 * x - y",
"+if sa % 2 == 0 and x * 2 <= y and x * 4 >= y:",
"+ print(\"Yes\")",
"+else:",
"-",
"-",
"-if __name__ == \"__main__\":",
"- main()"
] | false | 0.045326 | 0.044258 | 1.024133 |
[
"s961289719",
"s599626802"
] |
u411203878
|
p03612
|
python
|
s325608460
|
s036191064
| 217 | 88 | 53,868 | 83,988 |
Accepted
|
Accepted
| 59.45 |
N = int(eval(input()))
p = tuple(map(int, input().split()))
cont = 0
ans = 0
for idx, pi in enumerate(p):
i = idx + 1
if i == pi:
cont += 1
else:
ans += (cont + 1) // 2
cont = 0
ans += (cont + 1) // 2
print(ans)
|
N = int(eval(input()))
P = list(map(int,input().split()))
ans = 0
for i in range(N):
if P[i] == i+1:
if i < N-1:
now = P[i]
P[i] = P[i+1]
P[i+1] = now
ans += 1
print(ans)
| 16 | 14 | 262 | 236 |
N = int(eval(input()))
p = tuple(map(int, input().split()))
cont = 0
ans = 0
for idx, pi in enumerate(p):
i = idx + 1
if i == pi:
cont += 1
else:
ans += (cont + 1) // 2
cont = 0
ans += (cont + 1) // 2
print(ans)
|
N = int(eval(input()))
P = list(map(int, input().split()))
ans = 0
for i in range(N):
if P[i] == i + 1:
if i < N - 1:
now = P[i]
P[i] = P[i + 1]
P[i + 1] = now
ans += 1
print(ans)
| false | 12.5 |
[
"-p = tuple(map(int, input().split()))",
"-cont = 0",
"+P = list(map(int, input().split()))",
"-for idx, pi in enumerate(p):",
"- i = idx + 1",
"- if i == pi:",
"- cont += 1",
"- else:",
"- ans += (cont + 1) // 2",
"- cont = 0",
"-ans += (cont + 1) // 2",
"+for i in range(N):",
"+ if P[i] == i + 1:",
"+ if i < N - 1:",
"+ now = P[i]",
"+ P[i] = P[i + 1]",
"+ P[i + 1] = now",
"+ ans += 1"
] | false | 0.038089 | 0.03581 | 1.063664 |
[
"s325608460",
"s036191064"
] |
u545368057
|
p03608
|
python
|
s129249525
|
s594351595
| 433 | 321 | 46,936 | 74,896 |
Accepted
|
Accepted
| 25.87 |
from itertools import permutations
n, m, r = list(map(int, input().split()))
INF = 1 << 60
d = [[INF] * n for i in range(n)]
rs = list(map(int, input().split()))
for i in range(m):
a,b,c = list(map(int, input().split()))
a -= 1
b -= 1
d[a][b] = c
d[b][a] = c
def warshall_floyd(d):
"""
input
d : 初期全点対距離
output
d : 最適化後全点対距離
"""
n = len(d)
for k in range(n):
for i in range(n):
for j in range(n):
d[i][j] = min(d[i][j],d[i][k]+d[k][j])
return d
d_optimized = warshall_floyd(d)
# print(d_optimized)
ans = INF
for inds in permutations([r-1 for r in rs]):
cnt = 0
for i in range(r-1):
prev = inds[i]
nxt = inds[i+1]
cnt += d_optimized[prev][nxt]
ans = min(ans,cnt)
print(ans)
|
n,m,r = list(map(int, input().split()))
INF = 1 << 40
edges = [[INF]*n for i in range(n)]
rs = list(map(int, input().split()))
rs = [r-1 for r in rs]
for i in range(m):
a,b,c = list(map(int, input().split()))
a -= 1
b -= 1
edges[a][b] = c
edges[b][a] = c
for k in range(n):
for i in range(n):
for j in range(n):
tmp = edges[i][k] + edges[k][j]
edges[i][j] = min(edges[i][j], tmp)
from itertools import permutations
ans = 1 << 50
for perm in permutations(rs):
dist = 0
for i in range(1,len(perm)):
f = perm[i-1]
t = perm[i]
dist += edges[f][t]
ans = min(ans, dist)
print(ans)
| 40 | 29 | 840 | 686 |
from itertools import permutations
n, m, r = list(map(int, input().split()))
INF = 1 << 60
d = [[INF] * n for i in range(n)]
rs = list(map(int, input().split()))
for i in range(m):
a, b, c = list(map(int, input().split()))
a -= 1
b -= 1
d[a][b] = c
d[b][a] = c
def warshall_floyd(d):
"""
input
d : 初期全点対距離
output
d : 最適化後全点対距離
"""
n = len(d)
for k in range(n):
for i in range(n):
for j in range(n):
d[i][j] = min(d[i][j], d[i][k] + d[k][j])
return d
d_optimized = warshall_floyd(d)
# print(d_optimized)
ans = INF
for inds in permutations([r - 1 for r in rs]):
cnt = 0
for i in range(r - 1):
prev = inds[i]
nxt = inds[i + 1]
cnt += d_optimized[prev][nxt]
ans = min(ans, cnt)
print(ans)
|
n, m, r = list(map(int, input().split()))
INF = 1 << 40
edges = [[INF] * n for i in range(n)]
rs = list(map(int, input().split()))
rs = [r - 1 for r in rs]
for i in range(m):
a, b, c = list(map(int, input().split()))
a -= 1
b -= 1
edges[a][b] = c
edges[b][a] = c
for k in range(n):
for i in range(n):
for j in range(n):
tmp = edges[i][k] + edges[k][j]
edges[i][j] = min(edges[i][j], tmp)
from itertools import permutations
ans = 1 << 50
for perm in permutations(rs):
dist = 0
for i in range(1, len(perm)):
f = perm[i - 1]
t = perm[i]
dist += edges[f][t]
ans = min(ans, dist)
print(ans)
| false | 27.5 |
[
"-from itertools import permutations",
"-",
"-INF = 1 << 60",
"-d = [[INF] * n for i in range(n)]",
"+INF = 1 << 40",
"+edges = [[INF] * n for i in range(n)]",
"+rs = [r - 1 for r in rs]",
"- d[a][b] = c",
"- d[b][a] = c",
"+ edges[a][b] = c",
"+ edges[b][a] = c",
"+for k in range(n):",
"+ for i in range(n):",
"+ for j in range(n):",
"+ tmp = edges[i][k] + edges[k][j]",
"+ edges[i][j] = min(edges[i][j], tmp)",
"+from itertools import permutations",
"-",
"-def warshall_floyd(d):",
"- \"\"\"",
"- input",
"- d : 初期全点対距離",
"- output",
"- d : 最適化後全点対距離",
"- \"\"\"",
"- n = len(d)",
"- for k in range(n):",
"- for i in range(n):",
"- for j in range(n):",
"- d[i][j] = min(d[i][j], d[i][k] + d[k][j])",
"- return d",
"-",
"-",
"-d_optimized = warshall_floyd(d)",
"-# print(d_optimized)",
"-ans = INF",
"-for inds in permutations([r - 1 for r in rs]):",
"- cnt = 0",
"- for i in range(r - 1):",
"- prev = inds[i]",
"- nxt = inds[i + 1]",
"- cnt += d_optimized[prev][nxt]",
"- ans = min(ans, cnt)",
"+ans = 1 << 50",
"+for perm in permutations(rs):",
"+ dist = 0",
"+ for i in range(1, len(perm)):",
"+ f = perm[i - 1]",
"+ t = perm[i]",
"+ dist += edges[f][t]",
"+ ans = min(ans, dist)"
] | false | 0.037373 | 0.036877 | 1.013437 |
[
"s129249525",
"s594351595"
] |
u145950990
|
p02996
|
python
|
s438337797
|
s388078214
| 1,061 | 940 | 35,608 | 53,728 |
Accepted
|
Accepted
| 11.4 |
n = int(eval(input()))
b = []
for i in range(n):
x,y = list(map(int,input().split()))
b.append([y,x])
b.sort()
ans = 'Yes'
t = 0
for i in range(n):
t += b[i][1]
if t>b[i][0]:
ans='No'
print(ans)
|
n = int(eval(input()))
d = [list(map(int,input().split())) for i in range(n)]
d.sort(key=lambda x: x[1])
ans = 'Yes'
t = 0
for i in d:
t += i[0]
if t>i[1]:ans='No'
print(ans)
| 13 | 9 | 219 | 184 |
n = int(eval(input()))
b = []
for i in range(n):
x, y = list(map(int, input().split()))
b.append([y, x])
b.sort()
ans = "Yes"
t = 0
for i in range(n):
t += b[i][1]
if t > b[i][0]:
ans = "No"
print(ans)
|
n = int(eval(input()))
d = [list(map(int, input().split())) for i in range(n)]
d.sort(key=lambda x: x[1])
ans = "Yes"
t = 0
for i in d:
t += i[0]
if t > i[1]:
ans = "No"
print(ans)
| false | 30.769231 |
[
"-b = []",
"-for i in range(n):",
"- x, y = list(map(int, input().split()))",
"- b.append([y, x])",
"-b.sort()",
"+d = [list(map(int, input().split())) for i in range(n)]",
"+d.sort(key=lambda x: x[1])",
"-for i in range(n):",
"- t += b[i][1]",
"- if t > b[i][0]:",
"+for i in d:",
"+ t += i[0]",
"+ if t > i[1]:"
] | false | 0.035422 | 0.042335 | 0.836702 |
[
"s438337797",
"s388078214"
] |
u852690916
|
p02762
|
python
|
s213120485
|
s299813832
| 1,239 | 1,109 | 18,144 | 18,148 |
Accepted
|
Accepted
| 10.49 |
def main():
N, M, K=list(map(int, input().split()))
friend_or_block = [0 for _ in range(N)]
friends_chain = UnionFindTree(N)
for _ in range(M):
a, b = list(map(int, input().split()))
a, b = a-1, b-1
friends_chain.unite(a, b)
friend_or_block[a] += 1
friend_or_block[b] += 1
for _ in range(K):
c, d = list(map(int, input().split()))
c, d = c-1, d-1
if friends_chain.same(c, d):
friend_or_block[c] += 1
friend_or_block[d] += 1
print((' '.join(map(str, [friends_chain.count(i) - friend_or_block[i] - 1 for i in range(N)]))))
class UnionFindTree:
def __init__(self, n):
self.parent = [-1 for _ in range(n)]
def root(self, x):
p, seq = self.parent[x], list()
while p >= 0:
seq.append(x)
x, p = p, self.parent[p]
for c in seq: self.parent[c] = x
return x
def same(self, x, y): return self.root(x) == self.root(y)
def count(self, x): return -self.parent[self.root(x)]
def unite(self, x, y):
if self.count(x) < self.count(y): x, y = y, x
xr, yr = self.root(x), self.root(y)
if xr == yr: return
self.parent[xr] += self.parent[yr]
self.parent[yr] = xr
if __name__ == '__main__':
main()
|
def main():
N, M, K=list(map(int, input().split()))
friend_or_block = [0 for _ in range(N)]
friends_chain = UnionFindTree(N)
for _ in range(M):
a, b = list(map(int, input().split()))
a, b = a-1, b-1
friends_chain.unite(a, b)
friend_or_block[a] += 1
friend_or_block[b] += 1
for _ in range(K):
c, d = list(map(int, input().split()))
c, d = c-1, d-1
if friends_chain.same(c, d):
friend_or_block[c] += 1
friend_or_block[d] += 1
print((' '.join(map(str, [friends_chain.count(i) - friend_or_block[i] - 1 for i in range(N)]))))
class UnionFindTree:
def __init__(self, n):
self.parent = [-1 for _ in range(n)]
def root(self, x):
p, seq = self.parent[x], list()
while p >= 0:
seq.append(x)
x, p = p, self.parent[p]
for c in seq: self.parent[c] = x
return x
def same(self, x, y): return self.root(x) == self.root(y)
def count(self, x): return -self.parent[self.root(x)]
def unite(self, x, y):
xr, yr = self.root(x), self.root(y)
if xr == yr: return
if self.parent[xr] > self.parent[yr]: xr, yr = yr, xr
self.parent[xr] += self.parent[yr]
self.parent[yr] = xr
if __name__ == '__main__':
main()
| 47 | 47 | 1,351 | 1,359 |
def main():
N, M, K = list(map(int, input().split()))
friend_or_block = [0 for _ in range(N)]
friends_chain = UnionFindTree(N)
for _ in range(M):
a, b = list(map(int, input().split()))
a, b = a - 1, b - 1
friends_chain.unite(a, b)
friend_or_block[a] += 1
friend_or_block[b] += 1
for _ in range(K):
c, d = list(map(int, input().split()))
c, d = c - 1, d - 1
if friends_chain.same(c, d):
friend_or_block[c] += 1
friend_or_block[d] += 1
print(
(
" ".join(
map(
str,
[friends_chain.count(i) - friend_or_block[i] - 1 for i in range(N)],
)
)
)
)
class UnionFindTree:
def __init__(self, n):
self.parent = [-1 for _ in range(n)]
def root(self, x):
p, seq = self.parent[x], list()
while p >= 0:
seq.append(x)
x, p = p, self.parent[p]
for c in seq:
self.parent[c] = x
return x
def same(self, x, y):
return self.root(x) == self.root(y)
def count(self, x):
return -self.parent[self.root(x)]
def unite(self, x, y):
if self.count(x) < self.count(y):
x, y = y, x
xr, yr = self.root(x), self.root(y)
if xr == yr:
return
self.parent[xr] += self.parent[yr]
self.parent[yr] = xr
if __name__ == "__main__":
main()
|
def main():
N, M, K = list(map(int, input().split()))
friend_or_block = [0 for _ in range(N)]
friends_chain = UnionFindTree(N)
for _ in range(M):
a, b = list(map(int, input().split()))
a, b = a - 1, b - 1
friends_chain.unite(a, b)
friend_or_block[a] += 1
friend_or_block[b] += 1
for _ in range(K):
c, d = list(map(int, input().split()))
c, d = c - 1, d - 1
if friends_chain.same(c, d):
friend_or_block[c] += 1
friend_or_block[d] += 1
print(
(
" ".join(
map(
str,
[friends_chain.count(i) - friend_or_block[i] - 1 for i in range(N)],
)
)
)
)
class UnionFindTree:
def __init__(self, n):
self.parent = [-1 for _ in range(n)]
def root(self, x):
p, seq = self.parent[x], list()
while p >= 0:
seq.append(x)
x, p = p, self.parent[p]
for c in seq:
self.parent[c] = x
return x
def same(self, x, y):
return self.root(x) == self.root(y)
def count(self, x):
return -self.parent[self.root(x)]
def unite(self, x, y):
xr, yr = self.root(x), self.root(y)
if xr == yr:
return
if self.parent[xr] > self.parent[yr]:
xr, yr = yr, xr
self.parent[xr] += self.parent[yr]
self.parent[yr] = xr
if __name__ == "__main__":
main()
| false | 0 |
[
"- if self.count(x) < self.count(y):",
"- x, y = y, x",
"+ if self.parent[xr] > self.parent[yr]:",
"+ xr, yr = yr, xr"
] | false | 0.083072 | 0.069494 | 1.195392 |
[
"s213120485",
"s299813832"
] |
u777923818
|
p03215
|
python
|
s669174428
|
s845014957
| 1,725 | 1,385 | 67,196 | 67,196 |
Accepted
|
Accepted
| 19.71 |
# -*- coding: utf-8 -*-
def inpl(): return list(map(int, input().split()))
N, K = inpl()
A = inpl()
tmp = 0
S = [0]*N
Q = []
for i in range(N):
tmp += A[i]
S[i] = tmp
Q.append(tmp)
tmp = 0
for i in range(1, N):
tmp = S[i-1]
for j in range(i, N):
#print(i, j)
v = S[j] -S[i-1]
Q.append(v)
res = 0
while True:
ok = 0
for i in range(40):
num = res + int("1" + "0"*i, 2)
tmp = 0
for j in range(len(Q)):
if num & Q[j] == num:
tmp += 1
if tmp >= K:
ok = num
if res < ok:
res = ok
else:
break
print(res)
|
# -*- coding: utf-8 -*-
def inpl(): return list(map(int, input().split()))
N, K = inpl()
A = inpl()
tmp = 0
S = [0]*N
Q = []
for i in range(N):
tmp += A[i]
S[i] = tmp
Q.append(tmp)
tmp = 0
for i in range(1, N):
tmp = S[i-1]
for j in range(i, N):
#print(i, j)
v = S[j] -S[i-1]
Q.append(v)
res = 0
L = len(Q)
I = len(bin(sum(A))) - 2
while True:
ok = 0
for i in range(I):
num = res + 2**i
tmp = 0
for j in range(L):
if num & Q[j] == num:
tmp += 1
if tmp >= K:
ok = num
I = len(bin(res - ok)) - 2
if res < ok & ok > 0:
res = ok
else:
break
print(res)
| 37 | 42 | 683 | 745 |
# -*- coding: utf-8 -*-
def inpl():
return list(map(int, input().split()))
N, K = inpl()
A = inpl()
tmp = 0
S = [0] * N
Q = []
for i in range(N):
tmp += A[i]
S[i] = tmp
Q.append(tmp)
tmp = 0
for i in range(1, N):
tmp = S[i - 1]
for j in range(i, N):
# print(i, j)
v = S[j] - S[i - 1]
Q.append(v)
res = 0
while True:
ok = 0
for i in range(40):
num = res + int("1" + "0" * i, 2)
tmp = 0
for j in range(len(Q)):
if num & Q[j] == num:
tmp += 1
if tmp >= K:
ok = num
if res < ok:
res = ok
else:
break
print(res)
|
# -*- coding: utf-8 -*-
def inpl():
return list(map(int, input().split()))
N, K = inpl()
A = inpl()
tmp = 0
S = [0] * N
Q = []
for i in range(N):
tmp += A[i]
S[i] = tmp
Q.append(tmp)
tmp = 0
for i in range(1, N):
tmp = S[i - 1]
for j in range(i, N):
# print(i, j)
v = S[j] - S[i - 1]
Q.append(v)
res = 0
L = len(Q)
I = len(bin(sum(A))) - 2
while True:
ok = 0
for i in range(I):
num = res + 2**i
tmp = 0
for j in range(L):
if num & Q[j] == num:
tmp += 1
if tmp >= K:
ok = num
I = len(bin(res - ok)) - 2
if res < ok & ok > 0:
res = ok
else:
break
print(res)
| false | 11.904762 |
[
"+L = len(Q)",
"+I = len(bin(sum(A))) - 2",
"- for i in range(40):",
"- num = res + int(\"1\" + \"0\" * i, 2)",
"+ for i in range(I):",
"+ num = res + 2**i",
"- for j in range(len(Q)):",
"+ for j in range(L):",
"- if res < ok:",
"+ I = len(bin(res - ok)) - 2",
"+ if res < ok & ok > 0:"
] | false | 0.047006 | 0.041552 | 1.131273 |
[
"s669174428",
"s845014957"
] |
u852690916
|
p03229
|
python
|
s049830228
|
s998263816
| 533 | 111 | 51,288 | 89,368 |
Accepted
|
Accepted
| 79.17 |
N = int(eval(input()))
A = [int(eval(input())) for _ in range(N)]
A = sorted(A)
ans1 = 0
l = 0
r = N-1
for i in range(N-2):
if i%2 == 0:
ans1 += 2 * A[r]
r -= 1
else:
ans1 += -2 * A[l]
l += 1
if N%2 == 0:
ans1 -= min(A[l], A[r])
ans1 += max(A[l], A[r])
else:
ans1 -= (A[l] + A[r])
ans2 = 0
l = 0
r = N-1
for i in range(N-2):
if i%2 == 1:
ans2 += 2 * A[r]
r -= 1
else:
ans2 += -2 * A[l]
l += 1
if N%2 == 0:
ans2 -= min(A[l], A[r])
ans2 += max(A[l], A[r])
else:
ans2 += (A[l] + A[r])
print((max(ans1,ans2)))
|
# でつoO(YOU PLAY WITH THE CARDS YOU'RE DEALT..)
import sys
def main(N, A):
A.sort()
B = [A[i // 2] if i & 1 == 0 else A[-1 - i // 2] for i in range(N)]
C = [A[i // 2] if i & 1 == 1 else A[-1 - i // 2] for i in range(N)]
print((max(f(B), f(C))))
def f(L):
res = 0
for i in range(len(L) - 1):
res += abs(L[i] - L[i - 1])
return res
if __name__ == '__main__':
input = sys.stdin.readline
N = int(eval(input()))
A = [int(eval(input())) for _ in range(N)]
main(N, A)
| 37 | 20 | 635 | 520 |
N = int(eval(input()))
A = [int(eval(input())) for _ in range(N)]
A = sorted(A)
ans1 = 0
l = 0
r = N - 1
for i in range(N - 2):
if i % 2 == 0:
ans1 += 2 * A[r]
r -= 1
else:
ans1 += -2 * A[l]
l += 1
if N % 2 == 0:
ans1 -= min(A[l], A[r])
ans1 += max(A[l], A[r])
else:
ans1 -= A[l] + A[r]
ans2 = 0
l = 0
r = N - 1
for i in range(N - 2):
if i % 2 == 1:
ans2 += 2 * A[r]
r -= 1
else:
ans2 += -2 * A[l]
l += 1
if N % 2 == 0:
ans2 -= min(A[l], A[r])
ans2 += max(A[l], A[r])
else:
ans2 += A[l] + A[r]
print((max(ans1, ans2)))
|
# でつoO(YOU PLAY WITH THE CARDS YOU'RE DEALT..)
import sys
def main(N, A):
A.sort()
B = [A[i // 2] if i & 1 == 0 else A[-1 - i // 2] for i in range(N)]
C = [A[i // 2] if i & 1 == 1 else A[-1 - i // 2] for i in range(N)]
print((max(f(B), f(C))))
def f(L):
res = 0
for i in range(len(L) - 1):
res += abs(L[i] - L[i - 1])
return res
if __name__ == "__main__":
input = sys.stdin.readline
N = int(eval(input()))
A = [int(eval(input())) for _ in range(N)]
main(N, A)
| false | 45.945946 |
[
"-N = int(eval(input()))",
"-A = [int(eval(input())) for _ in range(N)]",
"-A = sorted(A)",
"-ans1 = 0",
"-l = 0",
"-r = N - 1",
"-for i in range(N - 2):",
"- if i % 2 == 0:",
"- ans1 += 2 * A[r]",
"- r -= 1",
"- else:",
"- ans1 += -2 * A[l]",
"- l += 1",
"-if N % 2 == 0:",
"- ans1 -= min(A[l], A[r])",
"- ans1 += max(A[l], A[r])",
"-else:",
"- ans1 -= A[l] + A[r]",
"-ans2 = 0",
"-l = 0",
"-r = N - 1",
"-for i in range(N - 2):",
"- if i % 2 == 1:",
"- ans2 += 2 * A[r]",
"- r -= 1",
"- else:",
"- ans2 += -2 * A[l]",
"- l += 1",
"-if N % 2 == 0:",
"- ans2 -= min(A[l], A[r])",
"- ans2 += max(A[l], A[r])",
"-else:",
"- ans2 += A[l] + A[r]",
"-print((max(ans1, ans2)))",
"+# でつoO(YOU PLAY WITH THE CARDS YOU'RE DEALT..)",
"+import sys",
"+",
"+",
"+def main(N, A):",
"+ A.sort()",
"+ B = [A[i // 2] if i & 1 == 0 else A[-1 - i // 2] for i in range(N)]",
"+ C = [A[i // 2] if i & 1 == 1 else A[-1 - i // 2] for i in range(N)]",
"+ print((max(f(B), f(C))))",
"+",
"+",
"+def f(L):",
"+ res = 0",
"+ for i in range(len(L) - 1):",
"+ res += abs(L[i] - L[i - 1])",
"+ return res",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ input = sys.stdin.readline",
"+ N = int(eval(input()))",
"+ A = [int(eval(input())) for _ in range(N)]",
"+ main(N, A)"
] | false | 0.03391 | 0.038197 | 0.887757 |
[
"s049830228",
"s998263816"
] |
u327466606
|
p04015
|
python
|
s330513179
|
s320271144
| 182 | 55 | 3,572 | 3,572 |
Accepted
|
Accepted
| 69.78 |
N, A = list(map(int, input().split(' ')))
X = list(map(int, input().split(' ')))
X = [x - A for x in X]
from collections import defaultdict
counter = defaultdict(int)
counter[0] = 1
for x in X:
copy = dict(counter)
for d,c in list(copy.items()):
counter[d+x] += c
print((counter[0]-1))
|
from collections import defaultdict
N, A = list(map(int, input().split()))
X = [int(s) - A for s in input().split()]
counter = defaultdict(int)
counter[0] = 1
for x in X:
for d,c in list(counter.items()):
counter[d+x] += c
print((counter[0]-1))
| 15 | 14 | 287 | 265 |
N, A = list(map(int, input().split(" ")))
X = list(map(int, input().split(" ")))
X = [x - A for x in X]
from collections import defaultdict
counter = defaultdict(int)
counter[0] = 1
for x in X:
copy = dict(counter)
for d, c in list(copy.items()):
counter[d + x] += c
print((counter[0] - 1))
|
from collections import defaultdict
N, A = list(map(int, input().split()))
X = [int(s) - A for s in input().split()]
counter = defaultdict(int)
counter[0] = 1
for x in X:
for d, c in list(counter.items()):
counter[d + x] += c
print((counter[0] - 1))
| false | 6.666667 |
[
"-N, A = list(map(int, input().split(\" \")))",
"-X = list(map(int, input().split(\" \")))",
"-X = [x - A for x in X]",
"+N, A = list(map(int, input().split()))",
"+X = [int(s) - A for s in input().split()]",
"- copy = dict(counter)",
"- for d, c in list(copy.items()):",
"+ for d, c in list(counter.items()):"
] | false | 0.083006 | 0.04182 | 1.984828 |
[
"s330513179",
"s320271144"
] |
u510331904
|
p02683
|
python
|
s414792040
|
s981992100
| 145 | 104 | 73,248 | 73,316 |
Accepted
|
Accepted
| 28.28 |
#!/usr/bin/env python3
import sys
import math
import decimal
import itertools
from itertools import product
from functools import reduce
def input():
return sys.stdin.readline()[:-1]
def main():
N, M, X = list(map(int, input().split()))
A = [list(map(int, input().split())) for _ in range(N)]
inf = 10**18
# bit全探索
# repeat=2だと(0,0), (0,1), (1,0), (1,1)になる
ans = inf
for i in product([0,1], repeat=N):
ok = True
for m in range(1, M + 1):
s = 0
for n in range(N):
if i[n] == 1:
s += A[n][m]
if s < X:
ok = False
if ok:
money = 0
for n in range(N):
if i[n] == 1:
money += A[n][0]
ans = min(ans, money)
if ans == inf:
print((-1))
else:
print(ans)
if __name__ == '__main__':
main()
|
#!/usr/bin/env python3
import sys
import math
import decimal
import itertools
from itertools import product
from functools import reduce
def input():
return sys.stdin.readline()[:-1]
def main():
N, M, X = list(map(int, input().split()))
A = [list(map(int, input().split())) for _ in range(N)]
inf = 10**18
# bit全探索
# repeat=2だと(0,0), (0,1), (1,0), (1,1)になる
ans = inf
for i in product([0,1], repeat=N):
ok = True
for m in range(1, M + 1):
s = 0
for n in range(N):
if i[n] == 1:
s += A[n][m]
if s < X:
ok = False
break
if ok:
money = 0
for n in range(N):
if i[n] == 1:
money += A[n][0]
ans = min(ans, money)
if ans == inf:
print((-1))
else:
print(ans)
if __name__ == '__main__':
main()
| 42 | 43 | 960 | 983 |
#!/usr/bin/env python3
import sys
import math
import decimal
import itertools
from itertools import product
from functools import reduce
def input():
return sys.stdin.readline()[:-1]
def main():
N, M, X = list(map(int, input().split()))
A = [list(map(int, input().split())) for _ in range(N)]
inf = 10**18
# bit全探索
# repeat=2だと(0,0), (0,1), (1,0), (1,1)になる
ans = inf
for i in product([0, 1], repeat=N):
ok = True
for m in range(1, M + 1):
s = 0
for n in range(N):
if i[n] == 1:
s += A[n][m]
if s < X:
ok = False
if ok:
money = 0
for n in range(N):
if i[n] == 1:
money += A[n][0]
ans = min(ans, money)
if ans == inf:
print((-1))
else:
print(ans)
if __name__ == "__main__":
main()
|
#!/usr/bin/env python3
import sys
import math
import decimal
import itertools
from itertools import product
from functools import reduce
def input():
return sys.stdin.readline()[:-1]
def main():
N, M, X = list(map(int, input().split()))
A = [list(map(int, input().split())) for _ in range(N)]
inf = 10**18
# bit全探索
# repeat=2だと(0,0), (0,1), (1,0), (1,1)になる
ans = inf
for i in product([0, 1], repeat=N):
ok = True
for m in range(1, M + 1):
s = 0
for n in range(N):
if i[n] == 1:
s += A[n][m]
if s < X:
ok = False
break
if ok:
money = 0
for n in range(N):
if i[n] == 1:
money += A[n][0]
ans = min(ans, money)
if ans == inf:
print((-1))
else:
print(ans)
if __name__ == "__main__":
main()
| false | 2.325581 |
[
"+ break"
] | false | 0.082869 | 0.037667 | 2.200042 |
[
"s414792040",
"s981992100"
] |
u067677727
|
p02240
|
python
|
s688872632
|
s522415903
| 810 | 610 | 32,904 | 41,016 |
Accepted
|
Accepted
| 24.69 |
# -*- coding: utf-8 -*-
def assignColor():
for i in range(n):
if C[i] == -1:
#BFS(i)
DFS(i)
#@profile
def BFS(start):
global C
Q = [start]
C[start] = start
while len(Q) != 0:
u = Q.pop(0)
v = [i for i in G[u] if C[i] == -1] # v := ??£??\???????????????????????¢?´¢??????????????????
for i in v:
Q.append(i)
C[i] = C[start]
#@profile
def DFS(start):
S = [start]
C[start] = start
while len(S) != 0:
u = S.pop(0)
for i in G[u]:
if C[i] == -1:
C[i] = start
S.append(i)
if __name__ == "__main__":
n, m = list(map(int, input().split()))
G = [[] for i in range(n)]
C = [-1]*n
for i in range(m):
s, t = list(map(int, input().split()))
G[s].append(t)
G[t].append(s)
assignColor()
q = int(eval(input()))
for i in range(q):
s, t = list(map(int, input().split()))
if C[s] == C[t]:
print("yes")
else:
print("no")
|
# -*- coding: utf-8 -*-
import sys
def assignColor():
for i in range(n):
if C[i] == -1:
#BFS(i)
DFS(i)
def BFS(start):
global C
Q = [start]
C[start] = start
while len(Q) != 0:
u = Q.pop(0)
v = [i for i in G[u] if C[i] == -1] # v := ??£??\???????????????????????¢?´¢??????????????????
for i in v:
Q.append(i)
C[i] = C[start]
#@profile
def DFS(start):
S = [start]
C[start] = start
while len(S) != 0:
u = S.pop(0)
for i in G[u]:
if C[i] == -1:
C[i] = start
S.append(i)
if __name__ == "__main__":
_input = sys.stdin.readlines()
n, m = list(map(int, _input[0].split()))
G = [[] for i in range(n)]
C = [-1]*n
for i in range(m):
s, t = list(map(int, _input[i+1].split()))
G[s].append(t)
G[t].append(s)
assignColor()
q = int(_input[m+1])
for i in range(q):
s, t = list(map(int, _input[m+i+2].split()))
if C[s] == C[t]:
print("yes")
else:
print("no")
| 51 | 53 | 1,159 | 1,202 |
# -*- coding: utf-8 -*-
def assignColor():
for i in range(n):
if C[i] == -1:
# BFS(i)
DFS(i)
# @profile
def BFS(start):
global C
Q = [start]
C[start] = start
while len(Q) != 0:
u = Q.pop(0)
v = [
i for i in G[u] if C[i] == -1
] # v := ??£??\???????????????????????¢?´¢??????????????????
for i in v:
Q.append(i)
C[i] = C[start]
# @profile
def DFS(start):
S = [start]
C[start] = start
while len(S) != 0:
u = S.pop(0)
for i in G[u]:
if C[i] == -1:
C[i] = start
S.append(i)
if __name__ == "__main__":
n, m = list(map(int, input().split()))
G = [[] for i in range(n)]
C = [-1] * n
for i in range(m):
s, t = list(map(int, input().split()))
G[s].append(t)
G[t].append(s)
assignColor()
q = int(eval(input()))
for i in range(q):
s, t = list(map(int, input().split()))
if C[s] == C[t]:
print("yes")
else:
print("no")
|
# -*- coding: utf-8 -*-
import sys
def assignColor():
for i in range(n):
if C[i] == -1:
# BFS(i)
DFS(i)
def BFS(start):
global C
Q = [start]
C[start] = start
while len(Q) != 0:
u = Q.pop(0)
v = [
i for i in G[u] if C[i] == -1
] # v := ??£??\???????????????????????¢?´¢??????????????????
for i in v:
Q.append(i)
C[i] = C[start]
# @profile
def DFS(start):
S = [start]
C[start] = start
while len(S) != 0:
u = S.pop(0)
for i in G[u]:
if C[i] == -1:
C[i] = start
S.append(i)
if __name__ == "__main__":
_input = sys.stdin.readlines()
n, m = list(map(int, _input[0].split()))
G = [[] for i in range(n)]
C = [-1] * n
for i in range(m):
s, t = list(map(int, _input[i + 1].split()))
G[s].append(t)
G[t].append(s)
assignColor()
q = int(_input[m + 1])
for i in range(q):
s, t = list(map(int, _input[m + i + 2].split()))
if C[s] == C[t]:
print("yes")
else:
print("no")
| false | 3.773585 |
[
"+import sys",
"+",
"+",
"-# @profile",
"- n, m = list(map(int, input().split()))",
"+ _input = sys.stdin.readlines()",
"+ n, m = list(map(int, _input[0].split()))",
"- s, t = list(map(int, input().split()))",
"+ s, t = list(map(int, _input[i + 1].split()))",
"- q = int(eval(input()))",
"+ q = int(_input[m + 1])",
"- s, t = list(map(int, input().split()))",
"+ s, t = list(map(int, _input[m + i + 2].split()))"
] | false | 0.047819 | 0.048133 | 0.993482 |
[
"s688872632",
"s522415903"
] |
u185896732
|
p02936
|
python
|
s546838066
|
s435894380
| 1,824 | 1,609 | 268,464 | 268,464 |
Accepted
|
Accepted
| 11.79 |
#import pysnooper
#import os,re,sys,operator,math,heapq,string
#from collections import Counter,deque
#from operator import itemgetter
#from itertools import accumulate,combinations,groupby
from sys import stdin,setrecursionlimit
#from copy import deepcopy
setrecursionlimit(10**6)
def rec(pp,xx=-1):
for i in gragh[pp]:
if i==xx:
continue
ans[i]+=ans[pp]
rec(i,pp)
n,q=list(map(int,stdin.readline().rstrip().split()))
ans=[0]*n
gragh=[[]*n for _ in range(n)]
for _ in range(n-1):
a,b=list(map(int,stdin.readline().rstrip().split()))
a-=1
b-=1
gragh[a].append(b)
gragh[b].append(a)
for _ in range(q):
p,x=list(map(int,stdin.readline().rstrip().split()))
ans[p-1]+=x
rec(0)
print((*ans))
|
#import pysnooper
#import os,re,sys,operator,math,heapq,string
#from collections import Counter,deque
#from operator import itemgetter
#from itertools import accumulate,combinations,groupby,combinations_with_replacement
from sys import stdin,setrecursionlimit
#from copy import deepcopy
setrecursionlimit(10**6)
input=stdin.readline
def dfs(v,c=-1):
for i in graph[v]:
if i==c:
continue
root[i]+=root[v]
dfs(i,v)
n,q=list(map(int,input().split()))
graph=[[] for _ in range(n)]
root=[0]*n
for i in range(n-1):
a,b=list(map(int,input().split()))
graph[a-1].append(b-1)
graph[b-1].append(a-1)
for i in range(q):
p,x=list(map(int,input().split()))
root[p-1]+=x
dfs(0)
print((*root))
| 32 | 30 | 770 | 750 |
# import pysnooper
# import os,re,sys,operator,math,heapq,string
# from collections import Counter,deque
# from operator import itemgetter
# from itertools import accumulate,combinations,groupby
from sys import stdin, setrecursionlimit
# from copy import deepcopy
setrecursionlimit(10**6)
def rec(pp, xx=-1):
for i in gragh[pp]:
if i == xx:
continue
ans[i] += ans[pp]
rec(i, pp)
n, q = list(map(int, stdin.readline().rstrip().split()))
ans = [0] * n
gragh = [[] * n for _ in range(n)]
for _ in range(n - 1):
a, b = list(map(int, stdin.readline().rstrip().split()))
a -= 1
b -= 1
gragh[a].append(b)
gragh[b].append(a)
for _ in range(q):
p, x = list(map(int, stdin.readline().rstrip().split()))
ans[p - 1] += x
rec(0)
print((*ans))
|
# import pysnooper
# import os,re,sys,operator,math,heapq,string
# from collections import Counter,deque
# from operator import itemgetter
# from itertools import accumulate,combinations,groupby,combinations_with_replacement
from sys import stdin, setrecursionlimit
# from copy import deepcopy
setrecursionlimit(10**6)
input = stdin.readline
def dfs(v, c=-1):
for i in graph[v]:
if i == c:
continue
root[i] += root[v]
dfs(i, v)
n, q = list(map(int, input().split()))
graph = [[] for _ in range(n)]
root = [0] * n
for i in range(n - 1):
a, b = list(map(int, input().split()))
graph[a - 1].append(b - 1)
graph[b - 1].append(a - 1)
for i in range(q):
p, x = list(map(int, input().split()))
root[p - 1] += x
dfs(0)
print((*root))
| false | 6.25 |
[
"-# from itertools import accumulate,combinations,groupby",
"+# from itertools import accumulate,combinations,groupby,combinations_with_replacement",
"+input = stdin.readline",
"-def rec(pp, xx=-1):",
"- for i in gragh[pp]:",
"- if i == xx:",
"+def dfs(v, c=-1):",
"+ for i in graph[v]:",
"+ if i == c:",
"- ans[i] += ans[pp]",
"- rec(i, pp)",
"+ root[i] += root[v]",
"+ dfs(i, v)",
"-n, q = list(map(int, stdin.readline().rstrip().split()))",
"-ans = [0] * n",
"-gragh = [[] * n for _ in range(n)]",
"-for _ in range(n - 1):",
"- a, b = list(map(int, stdin.readline().rstrip().split()))",
"- a -= 1",
"- b -= 1",
"- gragh[a].append(b)",
"- gragh[b].append(a)",
"-for _ in range(q):",
"- p, x = list(map(int, stdin.readline().rstrip().split()))",
"- ans[p - 1] += x",
"-rec(0)",
"-print((*ans))",
"+n, q = list(map(int, input().split()))",
"+graph = [[] for _ in range(n)]",
"+root = [0] * n",
"+for i in range(n - 1):",
"+ a, b = list(map(int, input().split()))",
"+ graph[a - 1].append(b - 1)",
"+ graph[b - 1].append(a - 1)",
"+for i in range(q):",
"+ p, x = list(map(int, input().split()))",
"+ root[p - 1] += x",
"+dfs(0)",
"+print((*root))"
] | false | 0.044856 | 0.007792 | 5.756362 |
[
"s546838066",
"s435894380"
] |
u909224749
|
p03102
|
python
|
s505994716
|
s345068829
| 32 | 28 | 9,216 | 9,184 |
Accepted
|
Accepted
| 12.5 |
N, M, C = list(map(int, input().split()))
B = list(map(int, input().split()))
A = [0]*N
count = 0
def a_x_b(ab):
a, b = ab
return a*b
for n in range(N):
A[n] = list(map(int, input().split()))
AB = [(A[n][i], B[i]) for i in range(M)]
if sum(list(map(a_x_b, AB)))+C > 0:
count += 1
else:
continue
print(count)
|
N, M, C = list(map(int, input().split()))
B = list(map(int, input().split()))
A = [0]*N
count = 0
for n in range(N):
A[n] = list(map(int, input().split()))
_sum = 0
for i in range(M):
_sum += A[n][i] * B[i]
if _sum + C > 0:
count += 1
else:
continue
print(count)
| 18 | 18 | 345 | 310 |
N, M, C = list(map(int, input().split()))
B = list(map(int, input().split()))
A = [0] * N
count = 0
def a_x_b(ab):
a, b = ab
return a * b
for n in range(N):
A[n] = list(map(int, input().split()))
AB = [(A[n][i], B[i]) for i in range(M)]
if sum(list(map(a_x_b, AB))) + C > 0:
count += 1
else:
continue
print(count)
|
N, M, C = list(map(int, input().split()))
B = list(map(int, input().split()))
A = [0] * N
count = 0
for n in range(N):
A[n] = list(map(int, input().split()))
_sum = 0
for i in range(M):
_sum += A[n][i] * B[i]
if _sum + C > 0:
count += 1
else:
continue
print(count)
| false | 0 |
[
"-",
"-",
"-def a_x_b(ab):",
"- a, b = ab",
"- return a * b",
"-",
"-",
"- AB = [(A[n][i], B[i]) for i in range(M)]",
"- if sum(list(map(a_x_b, AB))) + C > 0:",
"+ _sum = 0",
"+ for i in range(M):",
"+ _sum += A[n][i] * B[i]",
"+ if _sum + C > 0:"
] | false | 0.038748 | 0.131595 | 0.294449 |
[
"s505994716",
"s345068829"
] |
u346194435
|
p03069
|
python
|
s064205281
|
s342713443
| 364 | 76 | 19,448 | 3,500 |
Accepted
|
Accepted
| 79.12 |
import bisect
N = int(eval(input()))
S = eval(input())
# 右全部#
b = []
w = []
for i in range(N):
if S[i] == '#':
b.append(i)
if S[i] == '.':
w.append(i)
kouho = []
for i in range(0,N+1):
cost = 0
#iより右にある白の数
cost += len(w) - bisect.bisect_left(w,i)
#iより左にある黒の数
cost += bisect.bisect_left(b,i)
if cost >= 0:
kouho.append(cost)
print((min(kouho)))
|
N = int(eval(input()))
S = eval(input())
# 右全部#にする
w = S.count('.')
ans = 10**9
cost = 0
for c in S:
if c == '.':
# 今見てる所以降全部白にする事を考える
w -= 1
# まだ見てない白の数 + 今まで白にした黒のコストが答え候補
if w + cost < ans:
ans = w + cost
else:
# 今見てる所が黒の場合、白の個数は減らない
if w + cost< ans:
ans = w + cost
# 以降の計算に向けてコストを1増やす
cost += 1
print(ans)
| 24 | 24 | 415 | 421 |
import bisect
N = int(eval(input()))
S = eval(input())
# 右全部#
b = []
w = []
for i in range(N):
if S[i] == "#":
b.append(i)
if S[i] == ".":
w.append(i)
kouho = []
for i in range(0, N + 1):
cost = 0
# iより右にある白の数
cost += len(w) - bisect.bisect_left(w, i)
# iより左にある黒の数
cost += bisect.bisect_left(b, i)
if cost >= 0:
kouho.append(cost)
print((min(kouho)))
|
N = int(eval(input()))
S = eval(input())
# 右全部#にする
w = S.count(".")
ans = 10**9
cost = 0
for c in S:
if c == ".":
# 今見てる所以降全部白にする事を考える
w -= 1
# まだ見てない白の数 + 今まで白にした黒のコストが答え候補
if w + cost < ans:
ans = w + cost
else:
# 今見てる所が黒の場合、白の個数は減らない
if w + cost < ans:
ans = w + cost
# 以降の計算に向けてコストを1増やす
cost += 1
print(ans)
| false | 0 |
[
"-import bisect",
"-",
"-# 右全部#",
"-b = []",
"-w = []",
"-for i in range(N):",
"- if S[i] == \"#\":",
"- b.append(i)",
"- if S[i] == \".\":",
"- w.append(i)",
"-kouho = []",
"-for i in range(0, N + 1):",
"- cost = 0",
"- # iより右にある白の数",
"- cost += len(w) - bisect.bisect_left(w, i)",
"- # iより左にある黒の数",
"- cost += bisect.bisect_left(b, i)",
"- if cost >= 0:",
"- kouho.append(cost)",
"-print((min(kouho)))",
"+# 右全部#にする",
"+w = S.count(\".\")",
"+ans = 10**9",
"+cost = 0",
"+for c in S:",
"+ if c == \".\":",
"+ # 今見てる所以降全部白にする事を考える",
"+ w -= 1",
"+ # まだ見てない白の数 + 今まで白にした黒のコストが答え候補",
"+ if w + cost < ans:",
"+ ans = w + cost",
"+ else:",
"+ # 今見てる所が黒の場合、白の個数は減らない",
"+ if w + cost < ans:",
"+ ans = w + cost",
"+ # 以降の計算に向けてコストを1増やす",
"+ cost += 1",
"+print(ans)"
] | false | 0.160465 | 0.039191 | 4.094409 |
[
"s064205281",
"s342713443"
] |
u896741788
|
p03341
|
python
|
s432545283
|
s448056887
| 334 | 284 | 8,088 | 8,144 |
Accepted
|
Accepted
| 14.97 |
n=int(eval(input()))
S=eval(input())
w,e='W','E'
if e not in S or w not in S:print((0));exit()
ecnt=len([1 for i in list(S) if i==e])
p0,p1=0,ecnt-int(S[0]==e)
ans=p0+p1
for i in range(1,n):
p0,p1=(p0+int(S[i-1]==w),p1-int(S[i]==e))
#(l and gyaku,r and gyaku)
ans=min(ans,p0+p1)
print(ans)
|
n=int(eval(input()))
S=eval(input())
w,e='W','E'
if e not in S or w not in S:print((0));exit()
ecnt=len([1 for i in list(S) if i==e])
p0,p1=0,ecnt-int(S[0]==e)
ans=p0+p1
p=S[0]
for i in S[1:]:
p0,p1=(p0+int(p==w),p1-int(i==e))
#(l and gyaku,r and gyaku)
ans=min(ans,p0+p1)
p=i
print(ans)
| 12 | 14 | 292 | 294 |
n = int(eval(input()))
S = eval(input())
w, e = "W", "E"
if e not in S or w not in S:
print((0))
exit()
ecnt = len([1 for i in list(S) if i == e])
p0, p1 = 0, ecnt - int(S[0] == e)
ans = p0 + p1
for i in range(1, n):
p0, p1 = (p0 + int(S[i - 1] == w), p1 - int(S[i] == e))
# (l and gyaku,r and gyaku)
ans = min(ans, p0 + p1)
print(ans)
|
n = int(eval(input()))
S = eval(input())
w, e = "W", "E"
if e not in S or w not in S:
print((0))
exit()
ecnt = len([1 for i in list(S) if i == e])
p0, p1 = 0, ecnt - int(S[0] == e)
ans = p0 + p1
p = S[0]
for i in S[1:]:
p0, p1 = (p0 + int(p == w), p1 - int(i == e))
# (l and gyaku,r and gyaku)
ans = min(ans, p0 + p1)
p = i
print(ans)
| false | 14.285714 |
[
"-for i in range(1, n):",
"- p0, p1 = (p0 + int(S[i - 1] == w), p1 - int(S[i] == e))",
"+p = S[0]",
"+for i in S[1:]:",
"+ p0, p1 = (p0 + int(p == w), p1 - int(i == e))",
"+ p = i"
] | false | 0.0413 | 0.128221 | 0.3221 |
[
"s432545283",
"s448056887"
] |
u888092736
|
p02787
|
python
|
s245876463
|
s350965046
| 503 | 196 | 107,108 | 27,364 |
Accepted
|
Accepted
| 61.03 |
import numpy as np
from numba import njit, i8
@njit(i8(i8, i8[:], i8[:]), cache=True)
def solve(H, A, B):
A_max = A.max()
dp = np.zeros(H + A_max + 1, dtype=np.int64)
for i in range(A_max + 1, H + A_max + 1):
dp[i] = np.min(dp[i - A] + B)
return dp[-1]
H, N, *AB = list(map(int, open(0).read().split()))
A = np.array(AB[::2], dtype=np.int64)
B = np.array(AB[1::2], dtype=np.int64)
print((solve(H, A, B)))
|
import numpy as np
def solve(H, A, B):
A_max = A.max()
dp = np.zeros(H + A_max + 1, dtype=np.int64)
for i in range(A_max + 1, H + A_max + 1):
dp[i] = np.min(dp[i - A] + B)
return dp[-1]
H, N, *AB = list(map(int, open(0).read().split()))
A = np.array(AB[::2], dtype=np.int64)
B = np.array(AB[1::2], dtype=np.int64)
print((solve(H, A, B)))
| 17 | 15 | 441 | 372 |
import numpy as np
from numba import njit, i8
@njit(i8(i8, i8[:], i8[:]), cache=True)
def solve(H, A, B):
A_max = A.max()
dp = np.zeros(H + A_max + 1, dtype=np.int64)
for i in range(A_max + 1, H + A_max + 1):
dp[i] = np.min(dp[i - A] + B)
return dp[-1]
H, N, *AB = list(map(int, open(0).read().split()))
A = np.array(AB[::2], dtype=np.int64)
B = np.array(AB[1::2], dtype=np.int64)
print((solve(H, A, B)))
|
import numpy as np
def solve(H, A, B):
A_max = A.max()
dp = np.zeros(H + A_max + 1, dtype=np.int64)
for i in range(A_max + 1, H + A_max + 1):
dp[i] = np.min(dp[i - A] + B)
return dp[-1]
H, N, *AB = list(map(int, open(0).read().split()))
A = np.array(AB[::2], dtype=np.int64)
B = np.array(AB[1::2], dtype=np.int64)
print((solve(H, A, B)))
| false | 11.764706 |
[
"-from numba import njit, i8",
"-@njit(i8(i8, i8[:], i8[:]), cache=True)"
] | false | 0.593493 | 1.230722 | 0.482232 |
[
"s245876463",
"s350965046"
] |
u252828980
|
p03087
|
python
|
s645146468
|
s820542858
| 862 | 465 | 8,576 | 13,012 |
Accepted
|
Accepted
| 46.06 |
from itertools import accumulate
n,q = list(map(int,input().split()))
s = eval(input())
L = [0]*n
for i in range(n-1):
if s[i] == "A" and s[i+1] == "C":
L[i] = 0
L[i+1] = 1
LL = list(accumulate(L))
for i in range(q):
l,r = list(map(int,input().split()))
print((LL[r-1]-LL[l-1]))
|
n,k = list(map(int,input().split()))
a = eval(input())
L = [0]*n
for i in range(n-1):
if a[i] == "A" and a[i+1] == "C":
L[i] = 1
L = [0]+L
for i in range(n):
L[i+1] += L[i]
#print(L)
for i in range(k):
c,d = list(map(int,input().split()))
print((L[d-1]-L[c-1]))
| 14 | 15 | 302 | 281 |
from itertools import accumulate
n, q = list(map(int, input().split()))
s = eval(input())
L = [0] * n
for i in range(n - 1):
if s[i] == "A" and s[i + 1] == "C":
L[i] = 0
L[i + 1] = 1
LL = list(accumulate(L))
for i in range(q):
l, r = list(map(int, input().split()))
print((LL[r - 1] - LL[l - 1]))
|
n, k = list(map(int, input().split()))
a = eval(input())
L = [0] * n
for i in range(n - 1):
if a[i] == "A" and a[i + 1] == "C":
L[i] = 1
L = [0] + L
for i in range(n):
L[i + 1] += L[i]
# print(L)
for i in range(k):
c, d = list(map(int, input().split()))
print((L[d - 1] - L[c - 1]))
| false | 6.666667 |
[
"-from itertools import accumulate",
"-",
"-n, q = list(map(int, input().split()))",
"-s = eval(input())",
"+n, k = list(map(int, input().split()))",
"+a = eval(input())",
"- if s[i] == \"A\" and s[i + 1] == \"C\":",
"- L[i] = 0",
"- L[i + 1] = 1",
"-LL = list(accumulate(L))",
"-for i in range(q):",
"- l, r = list(map(int, input().split()))",
"- print((LL[r - 1] - LL[l - 1]))",
"+ if a[i] == \"A\" and a[i + 1] == \"C\":",
"+ L[i] = 1",
"+L = [0] + L",
"+for i in range(n):",
"+ L[i + 1] += L[i]",
"+# print(L)",
"+for i in range(k):",
"+ c, d = list(map(int, input().split()))",
"+ print((L[d - 1] - L[c - 1]))"
] | false | 0.045616 | 0.105001 | 0.434436 |
[
"s645146468",
"s820542858"
] |
u260216890
|
p02861
|
python
|
s901066566
|
s900355894
| 454 | 238 | 4,376 | 41,964 |
Accepted
|
Accepted
| 47.58 |
n=int(eval(input()))
xy=[]
for i in range(n):
xt,yt=list(map(int, input().split()))
xy.append((xt,yt))
from itertools import permutations
perms=permutations(xy)
dis=[]
for p in perms:
d_tmp=[]
for i in range(1,len(p)):
d=((p[i][0]-p[i-1][0])**2+(p[i][1]-p[i-1][1])**2)**0.5
d_tmp.append(d)
dis.append(sum(d_tmp))
print((sum(dis)/len(dis)))
|
n=int(eval(input()))
XY=[]
for i in range(n):
x,y=list(map(int,input().split()))
XY.append((x,y))
from itertools import permutations
perm=permutations(XY)
dists=[]
for i in perm:
dist=0
for j in range(1,n):
dist+=((i[j][0]-i[j-1][0])**2+(i[j][1]-i[j-1][1])**2)**0.5
dists.append(dist)
ans=sum(dists)/len(dists)
print(ans)
| 18 | 16 | 389 | 353 |
n = int(eval(input()))
xy = []
for i in range(n):
xt, yt = list(map(int, input().split()))
xy.append((xt, yt))
from itertools import permutations
perms = permutations(xy)
dis = []
for p in perms:
d_tmp = []
for i in range(1, len(p)):
d = ((p[i][0] - p[i - 1][0]) ** 2 + (p[i][1] - p[i - 1][1]) ** 2) ** 0.5
d_tmp.append(d)
dis.append(sum(d_tmp))
print((sum(dis) / len(dis)))
|
n = int(eval(input()))
XY = []
for i in range(n):
x, y = list(map(int, input().split()))
XY.append((x, y))
from itertools import permutations
perm = permutations(XY)
dists = []
for i in perm:
dist = 0
for j in range(1, n):
dist += ((i[j][0] - i[j - 1][0]) ** 2 + (i[j][1] - i[j - 1][1]) ** 2) ** 0.5
dists.append(dist)
ans = sum(dists) / len(dists)
print(ans)
| false | 11.111111 |
[
"-xy = []",
"+XY = []",
"- xt, yt = list(map(int, input().split()))",
"- xy.append((xt, yt))",
"+ x, y = list(map(int, input().split()))",
"+ XY.append((x, y))",
"-perms = permutations(xy)",
"-dis = []",
"-for p in perms:",
"- d_tmp = []",
"- for i in range(1, len(p)):",
"- d = ((p[i][0] - p[i - 1][0]) ** 2 + (p[i][1] - p[i - 1][1]) ** 2) ** 0.5",
"- d_tmp.append(d)",
"- dis.append(sum(d_tmp))",
"-print((sum(dis) / len(dis)))",
"+perm = permutations(XY)",
"+dists = []",
"+for i in perm:",
"+ dist = 0",
"+ for j in range(1, n):",
"+ dist += ((i[j][0] - i[j - 1][0]) ** 2 + (i[j][1] - i[j - 1][1]) ** 2) ** 0.5",
"+ dists.append(dist)",
"+ans = sum(dists) / len(dists)",
"+print(ans)"
] | false | 0.041744 | 0.042937 | 0.972215 |
[
"s901066566",
"s900355894"
] |
u879870653
|
p03209
|
python
|
s080634377
|
s766242441
| 20 | 18 | 3,064 | 3,064 |
Accepted
|
Accepted
| 10 |
N,X = list(map(int,input().split()))
L = [1]
for i in range(N) :
l = L[-1] + 2**(2+i)
L.append(l)
def dp(n,x) :
if x == 0 :
return 0
elif n == 0 :
return 1
elif n >= 1 :
if x == 1 :
return 0
elif x <= L[n-1]+1 :
return dp(n-1,x-1)
elif x == L[n-1]+2 :
return dp(n-1,L[n-1])+1
elif x <= L[n-1]*2+2 :
return dp(n-1,L[n-1])+1 + dp(n-1,x-L[n-1]-2)
else :
return dp(n-1,L[n-1])*2+1
print((dp(N,X)))
|
N,X = list(map(int,input().split()))
L = [1]
for i in range(50) :
L.append(L[-1]*2+3)
def dp(n,x) :
if x == 0 :
return 0
elif n == 0 :
return 1
elif n >= 1 :
if x == 1 :
return 0
elif x <= L[n-1]+1 :
return dp(n-1,x-1)
elif x == L[n-1]+2 :
return dp(n-1,x-1)+1
elif x <= L[n]-1 :
return dp(n-1,x-1)+1+dp(n-1,x-L[n-1]-2)
else :
return dp(n-1,x-1)*2+1
ans = dp(N,X)
print(ans)
| 24 | 24 | 559 | 526 |
N, X = list(map(int, input().split()))
L = [1]
for i in range(N):
l = L[-1] + 2 ** (2 + i)
L.append(l)
def dp(n, x):
if x == 0:
return 0
elif n == 0:
return 1
elif n >= 1:
if x == 1:
return 0
elif x <= L[n - 1] + 1:
return dp(n - 1, x - 1)
elif x == L[n - 1] + 2:
return dp(n - 1, L[n - 1]) + 1
elif x <= L[n - 1] * 2 + 2:
return dp(n - 1, L[n - 1]) + 1 + dp(n - 1, x - L[n - 1] - 2)
else:
return dp(n - 1, L[n - 1]) * 2 + 1
print((dp(N, X)))
|
N, X = list(map(int, input().split()))
L = [1]
for i in range(50):
L.append(L[-1] * 2 + 3)
def dp(n, x):
if x == 0:
return 0
elif n == 0:
return 1
elif n >= 1:
if x == 1:
return 0
elif x <= L[n - 1] + 1:
return dp(n - 1, x - 1)
elif x == L[n - 1] + 2:
return dp(n - 1, x - 1) + 1
elif x <= L[n] - 1:
return dp(n - 1, x - 1) + 1 + dp(n - 1, x - L[n - 1] - 2)
else:
return dp(n - 1, x - 1) * 2 + 1
ans = dp(N, X)
print(ans)
| false | 0 |
[
"-for i in range(N):",
"- l = L[-1] + 2 ** (2 + i)",
"- L.append(l)",
"+for i in range(50):",
"+ L.append(L[-1] * 2 + 3)",
"- return dp(n - 1, L[n - 1]) + 1",
"- elif x <= L[n - 1] * 2 + 2:",
"- return dp(n - 1, L[n - 1]) + 1 + dp(n - 1, x - L[n - 1] - 2)",
"+ return dp(n - 1, x - 1) + 1",
"+ elif x <= L[n] - 1:",
"+ return dp(n - 1, x - 1) + 1 + dp(n - 1, x - L[n - 1] - 2)",
"- return dp(n - 1, L[n - 1]) * 2 + 1",
"+ return dp(n - 1, x - 1) * 2 + 1",
"-print((dp(N, X)))",
"+ans = dp(N, X)",
"+print(ans)"
] | false | 0.041761 | 0.120956 | 0.345256 |
[
"s080634377",
"s766242441"
] |
u987164499
|
p02820
|
python
|
s656244009
|
s887464235
| 117 | 58 | 5,556 | 4,648 |
Accepted
|
Accepted
| 50.43 |
from itertools import groupby
n,k = list(map(int,input().split()))
r,s,p = list(map(int,input().split()))
t = list(eval(input()))
point = 0
for i in range(k):
li = ["x"]+t[i::k]
for j in range(1,len(li)):
if li[j-1] == li[j]:
li[j] = "x"
continue
if li[j] == "r":
point += p
elif li[j] == "s":
point += r
else:
point += s
print(point)
|
n,k = list(map(int,input().split()))
r,s,p = list(map(int,input().split()))
t = list(eval(input()))
point = 0
for i in t[:k]:
if i == "r":
point += p
elif i == "s":
point += r
else:
point += s
for i in range(k,n):
if t[i-k] == t[i]:
t[i] = "x"
continue
if t[i] == "r":
point += p
elif t[i] == "s":
point += r
else:
point += s
print(point)
| 22 | 25 | 445 | 439 |
from itertools import groupby
n, k = list(map(int, input().split()))
r, s, p = list(map(int, input().split()))
t = list(eval(input()))
point = 0
for i in range(k):
li = ["x"] + t[i::k]
for j in range(1, len(li)):
if li[j - 1] == li[j]:
li[j] = "x"
continue
if li[j] == "r":
point += p
elif li[j] == "s":
point += r
else:
point += s
print(point)
|
n, k = list(map(int, input().split()))
r, s, p = list(map(int, input().split()))
t = list(eval(input()))
point = 0
for i in t[:k]:
if i == "r":
point += p
elif i == "s":
point += r
else:
point += s
for i in range(k, n):
if t[i - k] == t[i]:
t[i] = "x"
continue
if t[i] == "r":
point += p
elif t[i] == "s":
point += r
else:
point += s
print(point)
| false | 12 |
[
"-from itertools import groupby",
"-",
"-for i in range(k):",
"- li = [\"x\"] + t[i::k]",
"- for j in range(1, len(li)):",
"- if li[j - 1] == li[j]:",
"- li[j] = \"x\"",
"- continue",
"- if li[j] == \"r\":",
"- point += p",
"- elif li[j] == \"s\":",
"- point += r",
"- else:",
"- point += s",
"+for i in t[:k]:",
"+ if i == \"r\":",
"+ point += p",
"+ elif i == \"s\":",
"+ point += r",
"+ else:",
"+ point += s",
"+for i in range(k, n):",
"+ if t[i - k] == t[i]:",
"+ t[i] = \"x\"",
"+ continue",
"+ if t[i] == \"r\":",
"+ point += p",
"+ elif t[i] == \"s\":",
"+ point += r",
"+ else:",
"+ point += s"
] | false | 0.037854 | 0.064757 | 0.584552 |
[
"s656244009",
"s887464235"
] |
u200887663
|
p02623
|
python
|
s430660013
|
s148612978
| 328 | 188 | 47,368 | 127,092 |
Accepted
|
Accepted
| 42.68 |
#n=int(input())
n,m,k=list(map(int,input().split()))
al=list(map(int,input().split()))
bl=list(map(int,input().split()))
#l=[list(map(int,input().split())) for i in range(n)]
import bisect
A=[0]
for i in range(n):
A.append(A[i]+al[i])
B=[0]
for i in range(m):
B.append(B[i]+bl[i])
#B.append(max(B[m],k)+1)
mx=0
for i in range(n+1):
rem=k-A[i]
if rem<0:
continue
bnum=bisect.bisect_right(B,rem)-1
mx=max(mx,i+bnum)
print(mx)
|
#k = int(input())
import bisect
n, m, k = list(map(int, input().split()))
al = list(map(int, input().split()))
bl = list(map(int, input().split()))
#al=[list(input()) for i in range(h)]
acum = [0]
for i in range(n):
acum.append(al[i]+acum[i])
bcum = [0]
for i in range(m):
bcum.append(bl[i]+bcum[i])
ans = 0
for i in range(n+1):
rsd = k-acum[i]
if rsd < 0:
break
#if rsd == 0:
# ans = max(ans, i)
# continue
ind = bisect.bisect_right(bcum, rsd)
ans = max(ans, i+ind-1)
print(ans)
| 22 | 24 | 472 | 548 |
# n=int(input())
n, m, k = list(map(int, input().split()))
al = list(map(int, input().split()))
bl = list(map(int, input().split()))
# l=[list(map(int,input().split())) for i in range(n)]
import bisect
A = [0]
for i in range(n):
A.append(A[i] + al[i])
B = [0]
for i in range(m):
B.append(B[i] + bl[i])
# B.append(max(B[m],k)+1)
mx = 0
for i in range(n + 1):
rem = k - A[i]
if rem < 0:
continue
bnum = bisect.bisect_right(B, rem) - 1
mx = max(mx, i + bnum)
print(mx)
|
# k = int(input())
import bisect
n, m, k = list(map(int, input().split()))
al = list(map(int, input().split()))
bl = list(map(int, input().split()))
# al=[list(input()) for i in range(h)]
acum = [0]
for i in range(n):
acum.append(al[i] + acum[i])
bcum = [0]
for i in range(m):
bcum.append(bl[i] + bcum[i])
ans = 0
for i in range(n + 1):
rsd = k - acum[i]
if rsd < 0:
break
# if rsd == 0:
# ans = max(ans, i)
# continue
ind = bisect.bisect_right(bcum, rsd)
ans = max(ans, i + ind - 1)
print(ans)
| false | 8.333333 |
[
"-# n=int(input())",
"+# k = int(input())",
"+import bisect",
"+",
"-# l=[list(map(int,input().split())) for i in range(n)]",
"-import bisect",
"-",
"-A = [0]",
"+# al=[list(input()) for i in range(h)]",
"+acum = [0]",
"- A.append(A[i] + al[i])",
"-B = [0]",
"+ acum.append(al[i] + acum[i])",
"+bcum = [0]",
"- B.append(B[i] + bl[i])",
"-# B.append(max(B[m],k)+1)",
"-mx = 0",
"+ bcum.append(bl[i] + bcum[i])",
"+ans = 0",
"- rem = k - A[i]",
"- if rem < 0:",
"- continue",
"- bnum = bisect.bisect_right(B, rem) - 1",
"- mx = max(mx, i + bnum)",
"-print(mx)",
"+ rsd = k - acum[i]",
"+ if rsd < 0:",
"+ break",
"+ # if rsd == 0:",
"+ # ans = max(ans, i)",
"+ # continue",
"+ ind = bisect.bisect_right(bcum, rsd)",
"+ ans = max(ans, i + ind - 1)",
"+print(ans)"
] | false | 0.031723 | 0.036519 | 0.868667 |
[
"s430660013",
"s148612978"
] |
u150984829
|
p02289
|
python
|
s998104869
|
s075790352
| 2,750 | 2,480 | 99,124 | 99,124 |
Accepted
|
Accepted
| 9.82 |
import sys
from heapq import heappush,heappop
H=[]
O=[]
for e in sys.stdin:
if'i'==e[0]:heappush(H,-int(e[7:]))
elif't'==e[2]:O+=[-heappop(H)]
else:print(('\n'.join(map(str,O))))
|
import sys
from heapq import*
H=[]
O=[]
for e in sys.stdin:
if'i'==e[0]:heappush(H,-int(e[7:]))
elif't'==e[2]:O+=[-heappop(H)]
else:print(('\n'.join(map(str,O))))
| 8 | 8 | 187 | 171 |
import sys
from heapq import heappush, heappop
H = []
O = []
for e in sys.stdin:
if "i" == e[0]:
heappush(H, -int(e[7:]))
elif "t" == e[2]:
O += [-heappop(H)]
else:
print(("\n".join(map(str, O))))
|
import sys
from heapq import *
H = []
O = []
for e in sys.stdin:
if "i" == e[0]:
heappush(H, -int(e[7:]))
elif "t" == e[2]:
O += [-heappop(H)]
else:
print(("\n".join(map(str, O))))
| false | 0 |
[
"-from heapq import heappush, heappop",
"+from heapq import *"
] | false | 0.054185 | 0.0465 | 1.165289 |
[
"s998104869",
"s075790352"
] |
u287500079
|
p02695
|
python
|
s424594866
|
s607394292
| 596 | 127 | 165,724 | 85,908 |
Accepted
|
Accepted
| 78.69 |
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, acos, atan, asin, log, log10, gcd
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
#from fractions import gcd
def debug(*args):
if debugmode:
print((*args))
def input(): return sys.stdin.readline().strip()
def STR(): return eval(input())
def INT(): return int(eval(input()))
def FLOAT(): return float(eval(input()))
def MAP(): return list(map(int, input().split()))
def S_MAP(): return list(map(str, input().split()))
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
def lcm(a, b): return a * b // gcd(a, b)
sys.setrecursionlimit(10 ** 9)
inf = sys.maxsize
mod = 10 ** 9 + 7
dx = [0, 1, 0, -1, 1, -1, -1, 1]
dy = [1, 0, -1, 0, 1, -1, 1, -1]
debugmode = True
n, m, q = MAP()
arr = [[]]
for i in range(n):
tmp = deepcopy(arr)
arr = []
for j in range(1, m + 1):
for k in range(len(tmp)):
if len(tmp[k]) == 0 or tmp[k][-1] <= j:
arr.append(deepcopy(tmp[k]))
arr[-1].append(j)
point = [0 for _ in range(len(arr))]
for i in range(q):
a, b, c, d = MAP()
for j in range(len(arr)):
if arr[j][b - 1] - arr[j][a - 1] == c:
point[j] += d
#print(point)
print((max(point)))
|
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, acos, atan, asin, log, log10, gcd
from itertools import permutations, combinations, product, accumulate, combinations_with_replacement
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
#from fractions import gcd
def debug(*args):
if debugmode:
print((*args))
def input(): return sys.stdin.readline().strip()
def STR(): return eval(input())
def INT(): return int(eval(input()))
def FLOAT(): return float(eval(input()))
def MAP(): return list(map(int, input().split()))
def S_MAP(): return list(map(str, input().split()))
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
def lcm(a, b): return a * b // gcd(a, b)
sys.setrecursionlimit(10 ** 9)
inf = sys.maxsize
mod = 10 ** 9 + 7
dx = [0, 1, 0, -1, 1, -1, -1, 1]
dy = [1, 0, -1, 0, 1, -1, 1, -1]
debugmode = True
n, m, q = MAP()
'''
arr = [[]]
for i in range(n):
tmp = deepcopy(arr)
arr = []
for j in range(1, m + 1):
for k in range(len(tmp)):
if len(tmp[k]) == 0 or tmp[k][-1] <= j:
arr.append(deepcopy(tmp[k]))
arr[-1].append(j)
'''
arr = list(combinations_with_replacement(list(range(1, m + 1)), n))
point = [0 for _ in range(len(arr))]
for i in range(q):
a, b, c, d = MAP()
for j in range(len(arr)):
if arr[j][b - 1] - arr[j][a - 1] == c:
point[j] += d
print((max(point)))
| 46 | 48 | 1,517 | 1,606 |
import sys, re, os
from collections import deque, defaultdict, Counter
from math import (
ceil,
sqrt,
hypot,
factorial,
pi,
sin,
cos,
radians,
acos,
atan,
asin,
log,
log10,
gcd,
)
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
# from fractions import gcd
def debug(*args):
if debugmode:
print((*args))
def input():
return sys.stdin.readline().strip()
def STR():
return eval(input())
def INT():
return int(eval(input()))
def FLOAT():
return float(eval(input()))
def MAP():
return list(map(int, input().split()))
def S_MAP():
return list(map(str, input().split()))
def LIST():
return list(map(int, input().split()))
def S_LIST():
return list(map(str, input().split()))
def lcm(a, b):
return a * b // gcd(a, b)
sys.setrecursionlimit(10**9)
inf = sys.maxsize
mod = 10**9 + 7
dx = [0, 1, 0, -1, 1, -1, -1, 1]
dy = [1, 0, -1, 0, 1, -1, 1, -1]
debugmode = True
n, m, q = MAP()
arr = [[]]
for i in range(n):
tmp = deepcopy(arr)
arr = []
for j in range(1, m + 1):
for k in range(len(tmp)):
if len(tmp[k]) == 0 or tmp[k][-1] <= j:
arr.append(deepcopy(tmp[k]))
arr[-1].append(j)
point = [0 for _ in range(len(arr))]
for i in range(q):
a, b, c, d = MAP()
for j in range(len(arr)):
if arr[j][b - 1] - arr[j][a - 1] == c:
point[j] += d
# print(point)
print((max(point)))
|
import sys, re, os
from collections import deque, defaultdict, Counter
from math import (
ceil,
sqrt,
hypot,
factorial,
pi,
sin,
cos,
radians,
acos,
atan,
asin,
log,
log10,
gcd,
)
from itertools import (
permutations,
combinations,
product,
accumulate,
combinations_with_replacement,
)
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
# from fractions import gcd
def debug(*args):
if debugmode:
print((*args))
def input():
return sys.stdin.readline().strip()
def STR():
return eval(input())
def INT():
return int(eval(input()))
def FLOAT():
return float(eval(input()))
def MAP():
return list(map(int, input().split()))
def S_MAP():
return list(map(str, input().split()))
def LIST():
return list(map(int, input().split()))
def S_LIST():
return list(map(str, input().split()))
def lcm(a, b):
return a * b // gcd(a, b)
sys.setrecursionlimit(10**9)
inf = sys.maxsize
mod = 10**9 + 7
dx = [0, 1, 0, -1, 1, -1, -1, 1]
dy = [1, 0, -1, 0, 1, -1, 1, -1]
debugmode = True
n, m, q = MAP()
"""
arr = [[]]
for i in range(n):
tmp = deepcopy(arr)
arr = []
for j in range(1, m + 1):
for k in range(len(tmp)):
if len(tmp[k]) == 0 or tmp[k][-1] <= j:
arr.append(deepcopy(tmp[k]))
arr[-1].append(j)
"""
arr = list(combinations_with_replacement(list(range(1, m + 1)), n))
point = [0 for _ in range(len(arr))]
for i in range(q):
a, b, c, d = MAP()
for j in range(len(arr)):
if arr[j][b - 1] - arr[j][a - 1] == c:
point[j] += d
print((max(point)))
| false | 4.166667 |
[
"-from itertools import permutations, combinations, product, accumulate",
"+from itertools import (",
"+ permutations,",
"+ combinations,",
"+ product,",
"+ accumulate,",
"+ combinations_with_replacement,",
"+)",
"+\"\"\"",
"+\"\"\"",
"+arr = list(combinations_with_replacement(list(range(1, m + 1)), n))",
"-# print(point)"
] | false | 0.491609 | 0.072426 | 6.787763 |
[
"s424594866",
"s607394292"
] |
u145950990
|
p03243
|
python
|
s099392452
|
s108327433
| 160 | 24 | 38,256 | 9,080 |
Accepted
|
Accepted
| 85 |
n = int(eval(input()))
ok = False
for i in range(1,10):
if int(str(i)*3)>=n:
print((str(i)*3))
exit()
|
n = int(eval(input()))
for i in range(1, 10):
if n <= i * 111:
print((i * 111))
exit()
| 6 | 5 | 118 | 103 |
n = int(eval(input()))
ok = False
for i in range(1, 10):
if int(str(i) * 3) >= n:
print((str(i) * 3))
exit()
|
n = int(eval(input()))
for i in range(1, 10):
if n <= i * 111:
print((i * 111))
exit()
| false | 16.666667 |
[
"-ok = False",
"- if int(str(i) * 3) >= n:",
"- print((str(i) * 3))",
"+ if n <= i * 111:",
"+ print((i * 111))"
] | false | 0.053456 | 0.054137 | 0.987411 |
[
"s099392452",
"s108327433"
] |
u711765449
|
p02400
|
python
|
s237405630
|
s085594992
| 30 | 20 | 7,540 | 7,404 |
Accepted
|
Accepted
| 33.33 |
# -*- coding:utf-8 -*-
import math
r = float(input())
a = r*r*math.pi
d = 2*r*math.pi
print(a,d,sep=' ')
|
pi = 3.14159265359
r = float(input())
a,d = r*r*pi,2*r*pi
print(a,d,sep=' ')
| 6 | 4 | 109 | 79 |
# -*- coding:utf-8 -*-
import math
r = float(input())
a = r * r * math.pi
d = 2 * r * math.pi
print(a, d, sep=" ")
|
pi = 3.14159265359
r = float(input())
a, d = r * r * pi, 2 * r * pi
print(a, d, sep=" ")
| false | 33.333333 |
[
"-# -*- coding:utf-8 -*-",
"-import math",
"-",
"+pi = 3.14159265359",
"-a = r * r * math.pi",
"-d = 2 * r * math.pi",
"+a, d = r * r * pi, 2 * r * pi"
] | false | 0.096958 | 0.039015 | 2.485123 |
[
"s237405630",
"s085594992"
] |
u842747358
|
p03211
|
python
|
s794619397
|
s851313067
| 19 | 17 | 2,940 | 2,940 |
Accepted
|
Accepted
| 10.53 |
S = eval(input())
li = []
for i in range(0, len(S)-2):
sli = int(S[i:i+3])
li.append(sli)
ans = 1000
for j in li:
ans = min(ans, abs(j-753))
print(ans)
|
S = eval(input())
ans = min(abs(int(S[i:i+3]) - 753) for i in range(len(S) - 2))
print(ans)
| 12 | 4 | 172 | 89 |
S = eval(input())
li = []
for i in range(0, len(S) - 2):
sli = int(S[i : i + 3])
li.append(sli)
ans = 1000
for j in li:
ans = min(ans, abs(j - 753))
print(ans)
|
S = eval(input())
ans = min(abs(int(S[i : i + 3]) - 753) for i in range(len(S) - 2))
print(ans)
| false | 66.666667 |
[
"-li = []",
"-for i in range(0, len(S) - 2):",
"- sli = int(S[i : i + 3])",
"- li.append(sli)",
"-ans = 1000",
"-for j in li:",
"- ans = min(ans, abs(j - 753))",
"+ans = min(abs(int(S[i : i + 3]) - 753) for i in range(len(S) - 2))"
] | false | 0.044504 | 0.043934 | 1.012984 |
[
"s794619397",
"s851313067"
] |
u394721319
|
p02832
|
python
|
s329301539
|
s811601479
| 141 | 104 | 26,268 | 32,200 |
Accepted
|
Accepted
| 26.24 |
N = int(eval(input()))
li = [int(zz) for zz in input().split()]
count = 1
ans = 0
ind = 0
while ind < N:
if li[ind] == count:
count += 1
ans += 1
ind += 1
if ans != 0:
print((N-ans))
else:
print((-1))
|
N = int(eval(input()))
A = [int(i) for i in input().split()]
ans = 0
c = 1
for i in range(N):
if A[i] == c:
c += 1
else:
ans += 1
if c == 1:
print((-1))
else:
print(ans)
| 16 | 15 | 240 | 210 |
N = int(eval(input()))
li = [int(zz) for zz in input().split()]
count = 1
ans = 0
ind = 0
while ind < N:
if li[ind] == count:
count += 1
ans += 1
ind += 1
if ans != 0:
print((N - ans))
else:
print((-1))
|
N = int(eval(input()))
A = [int(i) for i in input().split()]
ans = 0
c = 1
for i in range(N):
if A[i] == c:
c += 1
else:
ans += 1
if c == 1:
print((-1))
else:
print(ans)
| false | 6.25 |
[
"-li = [int(zz) for zz in input().split()]",
"-count = 1",
"+A = [int(i) for i in input().split()]",
"-ind = 0",
"-while ind < N:",
"- if li[ind] == count:",
"- count += 1",
"+c = 1",
"+for i in range(N):",
"+ if A[i] == c:",
"+ c += 1",
"+ else:",
"- ind += 1",
"-if ans != 0:",
"- print((N - ans))",
"+if c == 1:",
"+ print((-1))",
"- print((-1))",
"+ print(ans)"
] | false | 0.038012 | 0.036496 | 1.041534 |
[
"s329301539",
"s811601479"
] |
u562935282
|
p03262
|
python
|
s081138956
|
s351422267
| 92 | 75 | 14,480 | 14,224 |
Accepted
|
Accepted
| 18.48 |
def nl(): return list(map(int, input().split()))
def gcd(x, y):
if x < y:
# x >= y とする
x, y = y, x
while True:
r = x % y
if r == 0:
break
else:
x, y = y, r
return y
N, X = nl()
x = nl()
x2 = list(map(abs, ([v - X for v in x])))
g = x2[0]
for i in range(1, N):
g = gcd(g, x2[i])
print(g)
|
def gcd(x, y):
if x < y:# x >= y とする
x, y = y, x
r = x % y
res = y if r == 0 else gcd(y, r)
return res
N, X = list(map(int, input().split()))
x = list(map(int, input().split()))
x2 = [abs(i - X) for i in x]
g = x2[0]
for i in x2:
g = gcd(g, i)
print(g)
| 21 | 15 | 393 | 291 |
def nl():
return list(map(int, input().split()))
def gcd(x, y):
if x < y:
# x >= y とする
x, y = y, x
while True:
r = x % y
if r == 0:
break
else:
x, y = y, r
return y
N, X = nl()
x = nl()
x2 = list(map(abs, ([v - X for v in x])))
g = x2[0]
for i in range(1, N):
g = gcd(g, x2[i])
print(g)
|
def gcd(x, y):
if x < y: # x >= y とする
x, y = y, x
r = x % y
res = y if r == 0 else gcd(y, r)
return res
N, X = list(map(int, input().split()))
x = list(map(int, input().split()))
x2 = [abs(i - X) for i in x]
g = x2[0]
for i in x2:
g = gcd(g, i)
print(g)
| false | 28.571429 |
[
"-def nl():",
"- return list(map(int, input().split()))",
"+def gcd(x, y):",
"+ if x < y: # x >= y とする",
"+ x, y = y, x",
"+ r = x % y",
"+ res = y if r == 0 else gcd(y, r)",
"+ return res",
"-def gcd(x, y):",
"- if x < y:",
"- # x >= y とする",
"- x, y = y, x",
"- while True:",
"- r = x % y",
"- if r == 0:",
"- break",
"- else:",
"- x, y = y, r",
"- return y",
"-",
"-",
"-N, X = nl()",
"-x = nl()",
"-x2 = list(map(abs, ([v - X for v in x])))",
"+N, X = list(map(int, input().split()))",
"+x = list(map(int, input().split()))",
"+x2 = [abs(i - X) for i in x]",
"-for i in range(1, N):",
"- g = gcd(g, x2[i])",
"+for i in x2:",
"+ g = gcd(g, i)"
] | false | 0.037406 | 0.038038 | 0.983372 |
[
"s081138956",
"s351422267"
] |
u069533671
|
p03074
|
python
|
s955457642
|
s402771255
| 106 | 86 | 4,776 | 5,532 |
Accepted
|
Accepted
| 18.87 |
_, k = (list(map(int, input().split())))
n = [int(i) for i in list(eval(input()))]
rem = n[0]
s = [1]
for i in range(1, len(n)):
if n[i] == rem:
s[-1] += 1
else:
s.append(1)
rem = n[i]
imax = 0
sum_ = 0
r = 0
if n[0] == 0:
s.insert(0, 0)
for l in range(len(s)):
sum_ += s[l]
if l % 2 == 1 and l - r > k * 2:
r += 2
sum_ -= s[r-2] + s[r-1]
if sum_ > imax:
imax = sum_
print(imax)
|
n, k = [int(i) for i in input().split()]
s = [int(i) for i in eval(input())]
p = []
counter = 1
if s[0] == 0:
p.append(0)
for i in range(1, n):
if s[i] == s[i-1]:
counter += 1
else:
p.append(counter)
counter = 1
p.append(counter)
l = p[0::2] + [0, 0]
r = p[1::2]
counter = sum(r[:k]) + sum(l[:k+1])
imax = counter
for i in range(k, len(r)):
counter += l[i+1] + r[i]
counter -= l[i-k] + r[i-k]
if counter > imax:
imax = counter
print(imax)
| 26 | 27 | 466 | 518 |
_, k = list(map(int, input().split()))
n = [int(i) for i in list(eval(input()))]
rem = n[0]
s = [1]
for i in range(1, len(n)):
if n[i] == rem:
s[-1] += 1
else:
s.append(1)
rem = n[i]
imax = 0
sum_ = 0
r = 0
if n[0] == 0:
s.insert(0, 0)
for l in range(len(s)):
sum_ += s[l]
if l % 2 == 1 and l - r > k * 2:
r += 2
sum_ -= s[r - 2] + s[r - 1]
if sum_ > imax:
imax = sum_
print(imax)
|
n, k = [int(i) for i in input().split()]
s = [int(i) for i in eval(input())]
p = []
counter = 1
if s[0] == 0:
p.append(0)
for i in range(1, n):
if s[i] == s[i - 1]:
counter += 1
else:
p.append(counter)
counter = 1
p.append(counter)
l = p[0::2] + [0, 0]
r = p[1::2]
counter = sum(r[:k]) + sum(l[: k + 1])
imax = counter
for i in range(k, len(r)):
counter += l[i + 1] + r[i]
counter -= l[i - k] + r[i - k]
if counter > imax:
imax = counter
print(imax)
| false | 3.703704 |
[
"-_, k = list(map(int, input().split()))",
"-n = [int(i) for i in list(eval(input()))]",
"-rem = n[0]",
"-s = [1]",
"-for i in range(1, len(n)):",
"- if n[i] == rem:",
"- s[-1] += 1",
"+n, k = [int(i) for i in input().split()]",
"+s = [int(i) for i in eval(input())]",
"+p = []",
"+counter = 1",
"+if s[0] == 0:",
"+ p.append(0)",
"+for i in range(1, n):",
"+ if s[i] == s[i - 1]:",
"+ counter += 1",
"- s.append(1)",
"- rem = n[i]",
"-imax = 0",
"-sum_ = 0",
"-r = 0",
"-if n[0] == 0:",
"- s.insert(0, 0)",
"-for l in range(len(s)):",
"- sum_ += s[l]",
"- if l % 2 == 1 and l - r > k * 2:",
"- r += 2",
"- sum_ -= s[r - 2] + s[r - 1]",
"- if sum_ > imax:",
"- imax = sum_",
"+ p.append(counter)",
"+ counter = 1",
"+p.append(counter)",
"+l = p[0::2] + [0, 0]",
"+r = p[1::2]",
"+counter = sum(r[:k]) + sum(l[: k + 1])",
"+imax = counter",
"+for i in range(k, len(r)):",
"+ counter += l[i + 1] + r[i]",
"+ counter -= l[i - k] + r[i - k]",
"+ if counter > imax:",
"+ imax = counter"
] | false | 0.041728 | 0.041416 | 1.007547 |
[
"s955457642",
"s402771255"
] |
u163320134
|
p02675
|
python
|
s816105711
|
s160701587
| 22 | 20 | 9,176 | 9,176 |
Accepted
|
Accepted
| 9.09 |
n=int(eval(input()))
digit=n%10
if digit==0 or digit==1 or digit==6 or digit==8:
print('pon')
elif digit==2 or digit==4 or digit==5 or digit==7 or digit==9:
print('hon')
elif digit==3:
print('bon')
|
n=int(eval(input()))
if n%10 in [2,4,5,7,9]:
print('hon')
elif n%10 in [0,1,6,8]:
print('pon')
else:
print('bon')
| 8 | 7 | 204 | 119 |
n = int(eval(input()))
digit = n % 10
if digit == 0 or digit == 1 or digit == 6 or digit == 8:
print("pon")
elif digit == 2 or digit == 4 or digit == 5 or digit == 7 or digit == 9:
print("hon")
elif digit == 3:
print("bon")
|
n = int(eval(input()))
if n % 10 in [2, 4, 5, 7, 9]:
print("hon")
elif n % 10 in [0, 1, 6, 8]:
print("pon")
else:
print("bon")
| false | 12.5 |
[
"-digit = n % 10",
"-if digit == 0 or digit == 1 or digit == 6 or digit == 8:",
"+if n % 10 in [2, 4, 5, 7, 9]:",
"+ print(\"hon\")",
"+elif n % 10 in [0, 1, 6, 8]:",
"-elif digit == 2 or digit == 4 or digit == 5 or digit == 7 or digit == 9:",
"- print(\"hon\")",
"-elif digit == 3:",
"+else:"
] | false | 0.0399 | 0.091803 | 0.434622 |
[
"s816105711",
"s160701587"
] |
u445624660
|
p03592
|
python
|
s692145742
|
s549778201
| 368 | 321 | 3,064 | 3,064 |
Accepted
|
Accepted
| 12.77 |
# 横の回数をx, 縦の回数をyとすると k=x*(M-2)+y*(N-2)になればいい
# あとは例外 N or M==1のときはK<=N*Mからすべての値が可能
# N or M==2のときはすべての偶数が可能
# KがNorMで割り切れれば可能
# しょうがくせいのさんすうなのにあたまがわるすぎてくそどはまりしたよ せかいいちきょうぷろむいてないね いんたいしたほうがいいよ
n, m, k = list(map(int, input().split()))
if n == 1 or m == 1:
print("Yes")
exit()
if (n == 2 or m == 2) and k % 2 == 0:
print("Yes")
exit()
if k % n == 0 or k % m == 0:
print("Yes")
exit()
for y in range(1, n):
for x in range(1, m):
# print("y, x = {}, {}".format(y, x))
# print("面積 {}".format((y * m - x * y) + x * (n - y)))
if k == (y * m - x * y) + x * (n - y):
# print(y, x)
# print("y*x={}".format(y * x))
print("Yes")
exit()
print("No")
|
n, m, k = list(map(int, input().split()))
if n == 1 or m == 1:
print("Yes")
exit()
# これ必要か？？？？？？？？？？
# -> 意味不明だが必要らしい...
if k % n == 0 or k % m == 0:
print("Yes")
exit()
for p in range(n + 1):
for q in range(m + 1):
if p * (m - q) + q * (n - p) == k:
print("Yes")
exit()
print("No")
| 26 | 15 | 756 | 342 |
# 横の回数をx, 縦の回数をyとすると k=x*(M-2)+y*(N-2)になればいい
# あとは例外 N or M==1のときはK<=N*Mからすべての値が可能
# N or M==2のときはすべての偶数が可能
# KがNorMで割り切れれば可能
# しょうがくせいのさんすうなのにあたまがわるすぎてくそどはまりしたよ せかいいちきょうぷろむいてないね いんたいしたほうがいいよ
n, m, k = list(map(int, input().split()))
if n == 1 or m == 1:
print("Yes")
exit()
if (n == 2 or m == 2) and k % 2 == 0:
print("Yes")
exit()
if k % n == 0 or k % m == 0:
print("Yes")
exit()
for y in range(1, n):
for x in range(1, m):
# print("y, x = {}, {}".format(y, x))
# print("面積 {}".format((y * m - x * y) + x * (n - y)))
if k == (y * m - x * y) + x * (n - y):
# print(y, x)
# print("y*x={}".format(y * x))
print("Yes")
exit()
print("No")
|
n, m, k = list(map(int, input().split()))
if n == 1 or m == 1:
print("Yes")
exit()
# これ必要か？？？？？？？？？？
# -> 意味不明だが必要らしい...
if k % n == 0 or k % m == 0:
print("Yes")
exit()
for p in range(n + 1):
for q in range(m + 1):
if p * (m - q) + q * (n - p) == k:
print("Yes")
exit()
print("No")
| false | 42.307692 |
[
"-# 横の回数をx, 縦の回数をyとすると k=x*(M-2)+y*(N-2)になればいい",
"-# あとは例外 N or M==1のときはK<=N*Mからすべての値が可能",
"-# N or M==2のときはすべての偶数が可能",
"-# KがNorMで割り切れれば可能",
"-# しょうがくせいのさんすうなのにあたまがわるすぎてくそどはまりしたよ せかいいちきょうぷろむいてないね いんたいしたほうがいいよ",
"-if (n == 2 or m == 2) and k % 2 == 0:",
"- print(\"Yes\")",
"- exit()",
"+# これ必要か？？？？？？？？？？",
"+# -> 意味不明だが必要らしい...",
"-for y in range(1, n):",
"- for x in range(1, m):",
"- # print(\"y, x = {}, {}\".format(y, x))",
"- # print(\"面積 {}\".format((y * m - x * y) + x * (n - y)))",
"- if k == (y * m - x * y) + x * (n - y):",
"- # print(y, x)",
"- # print(\"y*x={}\".format(y * x))",
"+for p in range(n + 1):",
"+ for q in range(m + 1):",
"+ if p * (m - q) + q * (n - p) == k:"
] | false | 0.040089 | 0.041949 | 0.955657 |
[
"s692145742",
"s549778201"
] |
u729133443
|
p04021
|
python
|
s397836046
|
s666047851
| 744 | 78 | 17,796 | 24,060 |
Accepted
|
Accepted
| 89.52 |
print(sum(a[1]%2for a in sorted((eval(input()),i)for i in range(eval(input())))[::2]))
|
n,*a=list(map(int,open(0)))
print((len({*a[::2]}^{*sorted(a)[::2]})//2))
| 1 | 2 | 73 | 65 |
print(
sum(a[1] % 2 for a in sorted((eval(input()), i) for i in range(eval(input())))[::2])
)
|
n, *a = list(map(int, open(0)))
print((len({*a[::2]} ^ {*sorted(a)[::2]}) // 2))
| false | 50 |
[
"-print(",
"- sum(a[1] % 2 for a in sorted((eval(input()), i) for i in range(eval(input())))[::2])",
"-)",
"+n, *a = list(map(int, open(0)))",
"+print((len({*a[::2]} ^ {*sorted(a)[::2]}) // 2))"
] | false | 0.055906 | 0.034691 | 1.611544 |
[
"s397836046",
"s666047851"
] |
u604839890
|
p02688
|
python
|
s552626177
|
s646371806
| 64 | 30 | 67,804 | 9,140 |
Accepted
|
Accepted
| 53.12 |
n, k = list(map(int, input().split()))
a = []
for i in range(k):
d = int(eval(input()))
a[len(a):len(a)] = list(map(int, input().split()))
list(set(a))
ans = 0
for i in range(1, n+1):
if i not in a:
ans += 1
print(ans)
|
n, k = list(map(int, input().split()))
a = []
for i in range(k):
d = int(eval(input()))
a.extend(list(map(int, input().split())))
a = list(set(a))
print((n-len(a)))
| 11 | 7 | 226 | 164 |
n, k = list(map(int, input().split()))
a = []
for i in range(k):
d = int(eval(input()))
a[len(a) : len(a)] = list(map(int, input().split()))
list(set(a))
ans = 0
for i in range(1, n + 1):
if i not in a:
ans += 1
print(ans)
|
n, k = list(map(int, input().split()))
a = []
for i in range(k):
d = int(eval(input()))
a.extend(list(map(int, input().split())))
a = list(set(a))
print((n - len(a)))
| false | 36.363636 |
[
"- a[len(a) : len(a)] = list(map(int, input().split()))",
"-list(set(a))",
"-ans = 0",
"-for i in range(1, n + 1):",
"- if i not in a:",
"- ans += 1",
"-print(ans)",
"+ a.extend(list(map(int, input().split())))",
"+a = list(set(a))",
"+print((n - len(a)))"
] | false | 0.007908 | 0.034657 | 0.228184 |
[
"s552626177",
"s646371806"
] |
u867848444
|
p02954
|
python
|
s771936466
|
s199882654
| 177 | 155 | 13,336 | 13,432 |
Accepted
|
Accepted
| 12.43 |
s=eval(input())
cnt={'R':0,'L':0}
l=[]
cnt=0
for i in range(len(s)):
if i==len(s)-1:
if s[i]==s[i-1]:
l.append((s[i],cnt+1))
else:
l.append((s[i-1],cnt))
l.append((s[i],1))
elif i>=1 and s[i]!=s[i-1]:
l.append((s[i-1],cnt))
cnt=1
elif i==0 or s[i]==s[i-1]:
cnt+=1
#print(l)
ans=[0]*len(s)
index_num=-1
for i in range(len(l)):
s,num=l[i]
if i==0 and s=='L':
ans[0]=num
index_num+=num
if s=='R':
index_num+=num
ans[index_num]+=(num-1)//2+1
ans[index_num+1]+=num//2
else:
ans[index_num+1]+=(num-1)//2+1
ans[index_num]+=num//2
index_num+=num
#print(ans,index_num)
print((*ans))
|
s=eval(input())
def comp():
l=[]
temp_S=s[0]
cnt=1
for i in range(1,len(s)):
if s[i]==temp_S:cnt+=1
else:
l.append((temp_S,cnt))
cnt=1
temp_S=s[i]
l.append((temp_S,cnt))
return l
l=comp()
#print(l)
ans=[0]*len(s)
next_s='R'
cnt=0
for x,y in l:
if cnt==0 and x=='L':
ans[0]=y
cnt+=y
if x=='R':
cnt+=y
ans[cnt-1]+=(y+1)//2
ans[cnt]+=y-(y+1)//2
elif x=='L':
ans[cnt]+=(y+1)//2
ans[cnt-1]+=y-(y+1)//2
cnt+=y
print((*ans))
| 39 | 32 | 780 | 593 |
s = eval(input())
cnt = {"R": 0, "L": 0}
l = []
cnt = 0
for i in range(len(s)):
if i == len(s) - 1:
if s[i] == s[i - 1]:
l.append((s[i], cnt + 1))
else:
l.append((s[i - 1], cnt))
l.append((s[i], 1))
elif i >= 1 and s[i] != s[i - 1]:
l.append((s[i - 1], cnt))
cnt = 1
elif i == 0 or s[i] == s[i - 1]:
cnt += 1
# print(l)
ans = [0] * len(s)
index_num = -1
for i in range(len(l)):
s, num = l[i]
if i == 0 and s == "L":
ans[0] = num
index_num += num
if s == "R":
index_num += num
ans[index_num] += (num - 1) // 2 + 1
ans[index_num + 1] += num // 2
else:
ans[index_num + 1] += (num - 1) // 2 + 1
ans[index_num] += num // 2
index_num += num
# print(ans,index_num)
print((*ans))
|
s = eval(input())
def comp():
l = []
temp_S = s[0]
cnt = 1
for i in range(1, len(s)):
if s[i] == temp_S:
cnt += 1
else:
l.append((temp_S, cnt))
cnt = 1
temp_S = s[i]
l.append((temp_S, cnt))
return l
l = comp()
# print(l)
ans = [0] * len(s)
next_s = "R"
cnt = 0
for x, y in l:
if cnt == 0 and x == "L":
ans[0] = y
cnt += y
if x == "R":
cnt += y
ans[cnt - 1] += (y + 1) // 2
ans[cnt] += y - (y + 1) // 2
elif x == "L":
ans[cnt] += (y + 1) // 2
ans[cnt - 1] += y - (y + 1) // 2
cnt += y
print((*ans))
| false | 17.948718 |
[
"-cnt = {\"R\": 0, \"L\": 0}",
"-l = []",
"-cnt = 0",
"-for i in range(len(s)):",
"- if i == len(s) - 1:",
"- if s[i] == s[i - 1]:",
"- l.append((s[i], cnt + 1))",
"+",
"+",
"+def comp():",
"+ l = []",
"+ temp_S = s[0]",
"+ cnt = 1",
"+ for i in range(1, len(s)):",
"+ if s[i] == temp_S:",
"+ cnt += 1",
"- l.append((s[i - 1], cnt))",
"- l.append((s[i], 1))",
"- elif i >= 1 and s[i] != s[i - 1]:",
"- l.append((s[i - 1], cnt))",
"- cnt = 1",
"- elif i == 0 or s[i] == s[i - 1]:",
"- cnt += 1",
"+ l.append((temp_S, cnt))",
"+ cnt = 1",
"+ temp_S = s[i]",
"+ l.append((temp_S, cnt))",
"+ return l",
"+",
"+",
"+l = comp()",
"-index_num = -1",
"-for i in range(len(l)):",
"- s, num = l[i]",
"- if i == 0 and s == \"L\":",
"- ans[0] = num",
"- index_num += num",
"- if s == \"R\":",
"- index_num += num",
"- ans[index_num] += (num - 1) // 2 + 1",
"- ans[index_num + 1] += num // 2",
"- else:",
"- ans[index_num + 1] += (num - 1) // 2 + 1",
"- ans[index_num] += num // 2",
"- index_num += num",
"- # print(ans,index_num)",
"+next_s = \"R\"",
"+cnt = 0",
"+for x, y in l:",
"+ if cnt == 0 and x == \"L\":",
"+ ans[0] = y",
"+ cnt += y",
"+ if x == \"R\":",
"+ cnt += y",
"+ ans[cnt - 1] += (y + 1) // 2",
"+ ans[cnt] += y - (y + 1) // 2",
"+ elif x == \"L\":",
"+ ans[cnt] += (y + 1) // 2",
"+ ans[cnt - 1] += y - (y + 1) // 2",
"+ cnt += y"
] | false | 0.036607 | 0.061476 | 0.595474 |
[
"s771936466",
"s199882654"
] |
u279605379
|
p02297
|
python
|
s479875307
|
s646500453
| 30 | 20 | 7,744 | 7,756 |
Accepted
|
Accepted
| 33.33 |
def area(p,q):return p[0]*q[1]-p[1]*q[0]
n=int(eval(input()))
point=[]
x_1,y_1=[int(i) for i in input().split(" ")]
for _ in range(n-1):
x,y=[int(i) for i in input().split(" ")]
point.append([x-x_1,y-y_1])
a=0
for i in range(n-2):a+=area(point[i],point[i+1])
print((a*0.5))
|
n=int(eval(input()))
point=[]
x_1,y_1=[int(i) for i in input().split(" ")]
for _ in range(n-1):
x,y=[int(i) for i in input().split(" ")]
point.append([x-x_1,y-y_1])
a=0
for i in range(n-2):a+=point[i][0]*point[i+1][1] - point[i][1]*point[i+1][0]
print((a*0.5))
| 12 | 10 | 288 | 271 |
def area(p, q):
return p[0] * q[1] - p[1] * q[0]
n = int(eval(input()))
point = []
x_1, y_1 = [int(i) for i in input().split(" ")]
for _ in range(n - 1):
x, y = [int(i) for i in input().split(" ")]
point.append([x - x_1, y - y_1])
a = 0
for i in range(n - 2):
a += area(point[i], point[i + 1])
print((a * 0.5))
|
n = int(eval(input()))
point = []
x_1, y_1 = [int(i) for i in input().split(" ")]
for _ in range(n - 1):
x, y = [int(i) for i in input().split(" ")]
point.append([x - x_1, y - y_1])
a = 0
for i in range(n - 2):
a += point[i][0] * point[i + 1][1] - point[i][1] * point[i + 1][0]
print((a * 0.5))
| false | 16.666667 |
[
"-def area(p, q):",
"- return p[0] * q[1] - p[1] * q[0]",
"-",
"-",
"- a += area(point[i], point[i + 1])",
"+ a += point[i][0] * point[i + 1][1] - point[i][1] * point[i + 1][0]"
] | false | 0.072889 | 0.07103 | 1.026166 |
[
"s479875307",
"s646500453"
] |
u130900604
|
p03294
|
python
|
s224547789
|
s831904212
| 404 | 18 | 66,792 | 3,188 |
Accepted
|
Accepted
| 95.54 |
n=int(eval(input()))
a=list(map(int,input().split()))
from fractions import gcd
from functools import reduce
def lcm(x,y):
return x*y//gcd(x,y)
q=reduce(lcm,a)
ans=0
for i in a:
ans+=(q-1)%i
print(ans)
|
n=int(eval(input()))
print((sum(map(int,input().split()))-n))
| 14 | 3 | 215 | 57 |
n = int(eval(input()))
a = list(map(int, input().split()))
from fractions import gcd
from functools import reduce
def lcm(x, y):
return x * y // gcd(x, y)
q = reduce(lcm, a)
ans = 0
for i in a:
ans += (q - 1) % i
print(ans)
|
n = int(eval(input()))
print((sum(map(int, input().split())) - n))
| false | 78.571429 |
[
"-a = list(map(int, input().split()))",
"-from fractions import gcd",
"-from functools import reduce",
"-",
"-",
"-def lcm(x, y):",
"- return x * y // gcd(x, y)",
"-",
"-",
"-q = reduce(lcm, a)",
"-ans = 0",
"-for i in a:",
"- ans += (q - 1) % i",
"-print(ans)",
"+print((sum(map(int, input().split())) - n))"
] | false | 0.043867 | 0.033831 | 1.296645 |
[
"s224547789",
"s831904212"
] |
u678167152
|
p03624
|
python
|
s806564410
|
s145224227
| 162 | 36 | 39,152 | 3,188 |
Accepted
|
Accepted
| 77.78 |
S = eval(input())
ans='None'
for i in range(26):
s = chr(ord('a') + i)
if s not in S:
ans = s
break
print(ans)
#print(*ans, sep='\n')
|
def solve():
ans = 0
S = eval(input())
lis = [0]*26
for s in S:
lis[ord(s)-ord('a')] += 1
for i,l in enumerate(lis):
if l==0:
ans = chr(ord('a')+i)
return ans
return 'None'
print((solve()))
| 10 | 12 | 150 | 256 |
S = eval(input())
ans = "None"
for i in range(26):
s = chr(ord("a") + i)
if s not in S:
ans = s
break
print(ans)
# print(*ans, sep='\n')
|
def solve():
ans = 0
S = eval(input())
lis = [0] * 26
for s in S:
lis[ord(s) - ord("a")] += 1
for i, l in enumerate(lis):
if l == 0:
ans = chr(ord("a") + i)
return ans
return "None"
print((solve()))
| false | 16.666667 |
[
"-S = eval(input())",
"-ans = \"None\"",
"-for i in range(26):",
"- s = chr(ord(\"a\") + i)",
"- if s not in S:",
"- ans = s",
"- break",
"-print(ans)",
"-# print(*ans, sep='\\n')",
"+def solve():",
"+ ans = 0",
"+ S = eval(input())",
"+ lis = [0] * 26",
"+ for s in S:",
"+ lis[ord(s) - ord(\"a\")] += 1",
"+ for i, l in enumerate(lis):",
"+ if l == 0:",
"+ ans = chr(ord(\"a\") + i)",
"+ return ans",
"+ return \"None\"",
"+",
"+",
"+print((solve()))"
] | false | 0.040647 | 0.040018 | 1.015726 |
[
"s806564410",
"s145224227"
] |
u497952650
|
p02777
|
python
|
s842500206
|
s818086575
| 21 | 17 | 3,316 | 2,940 |
Accepted
|
Accepted
| 19.05 |
S,T = input().split()
A,B = map(int,input().split())
U = input()
if U == S:
A -= 1
elif U == T:
B -= 1
print(A,end=" ")
print(B)
|
S,T = input().split()
A,B = list(map(int,input().split()))
U = eval(input())
if U == S:
A -= 1
elif U == T:
B -= 1
print((A,B))
| 11 | 10 | 148 | 132 |
S, T = input().split()
A, B = map(int, input().split())
U = input()
if U == S:
A -= 1
elif U == T:
B -= 1
print(A, end=" ")
print(B)
|
S, T = input().split()
A, B = list(map(int, input().split()))
U = eval(input())
if U == S:
A -= 1
elif U == T:
B -= 1
print((A, B))
| false | 9.090909 |
[
"-A, B = map(int, input().split())",
"-U = input()",
"+A, B = list(map(int, input().split()))",
"+U = eval(input())",
"-print(A, end=\" \")",
"-print(B)",
"+print((A, B))"
] | false | 0.042883 | 0.042385 | 1.011748 |
[
"s842500206",
"s818086575"
] |
u761529120
|
p03108
|
python
|
s260353744
|
s171621628
| 1,209 | 1,097 | 102,744 | 98,392 |
Accepted
|
Accepted
| 9.26 |
class UnionFind(object):
def __init__(self, n=1):
self.par = [i for i in range(n)]
self.rank = [0 for _ in range(n)]
self.size = [1 for _ in range(n)]
def find(self, x):
"""
x が属するグループを探索
"""
# xが根だったら自分自身をreturnする
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def union(self, x, y):
"""
x と y のグループを結合
"""
x = self.find(x)
y = self.find(y)
if x != y:
if self.rank[x] < self.rank[y]:
x, y = y, x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
self.par[y] = x
self.size[x] += self.size[y]
def is_same(self, x, y):
"""
x と y が同じグループかどうか
"""
return self.find(x) == self.find(y)
def get_size(self, x):
"""
x が属するグループの要素数
"""
x = self.find(x)
return self.size[x]
def main():
N, M = list(map(int, input().split()))
A = [None] * M
B = [None] * M
for i in range(M):
A[i], B[i] = list(map(int, input().split()))
uni = UnionFind(N)
ans = [None] * M
ans[M-1] = N * (N - 1) // 2
for i in range(M - 1, 0, -1):
x = A[i] - 1
y = B[i] - 1
# 辺でつなげても元々同じグループに属していた場合、変化はしない
if uni.is_same(x, y):
ans[i - 1] = ans[i]
else:
ans[i - 1] = ans[i] - (uni.get_size(x) * uni.get_size(y))
uni.union(x, y)
for a in ans:
print(a)
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 same(self, x, y):
return self.find(x) == self.find(y)
def size(self, x):
return -self.parents[self.find(x)]
def main():
N, M = list(map(int, input().split()))
bridges = []
for _ in range(M):
A, B = list(map(int, input().split()))
A -= 1
B -= 1
bridges.append((A,B))
ans = [0] * M
ans[M-1] = N * (N - 1) // 2
uni = UnionFind(N)
for i in range(M-1,0,-1):
a, b = bridges[i]
if not uni.same(a, b):
ans[i-1] = ans[i] - (uni.size(a) * uni.size(b))
uni.union(a,b)
else:
ans[i-1] = ans[i]
for a in ans:
print(a)
if __name__ == "__main__":
main()
| 72 | 55 | 1,680 | 1,307 |
class UnionFind(object):
def __init__(self, n=1):
self.par = [i for i in range(n)]
self.rank = [0 for _ in range(n)]
self.size = [1 for _ in range(n)]
def find(self, x):
"""
x が属するグループを探索
"""
# xが根だったら自分自身をreturnする
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def union(self, x, y):
"""
x と y のグループを結合
"""
x = self.find(x)
y = self.find(y)
if x != y:
if self.rank[x] < self.rank[y]:
x, y = y, x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
self.par[y] = x
self.size[x] += self.size[y]
def is_same(self, x, y):
"""
x と y が同じグループかどうか
"""
return self.find(x) == self.find(y)
def get_size(self, x):
"""
x が属するグループの要素数
"""
x = self.find(x)
return self.size[x]
def main():
N, M = list(map(int, input().split()))
A = [None] * M
B = [None] * M
for i in range(M):
A[i], B[i] = list(map(int, input().split()))
uni = UnionFind(N)
ans = [None] * M
ans[M - 1] = N * (N - 1) // 2
for i in range(M - 1, 0, -1):
x = A[i] - 1
y = B[i] - 1
# 辺でつなげても元々同じグループに属していた場合、変化はしない
if uni.is_same(x, y):
ans[i - 1] = ans[i]
else:
ans[i - 1] = ans[i] - (uni.get_size(x) * uni.get_size(y))
uni.union(x, y)
for a in ans:
print(a)
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 same(self, x, y):
return self.find(x) == self.find(y)
def size(self, x):
return -self.parents[self.find(x)]
def main():
N, M = list(map(int, input().split()))
bridges = []
for _ in range(M):
A, B = list(map(int, input().split()))
A -= 1
B -= 1
bridges.append((A, B))
ans = [0] * M
ans[M - 1] = N * (N - 1) // 2
uni = UnionFind(N)
for i in range(M - 1, 0, -1):
a, b = bridges[i]
if not uni.same(a, b):
ans[i - 1] = ans[i] - (uni.size(a) * uni.size(b))
uni.union(a, b)
else:
ans[i - 1] = ans[i]
for a in ans:
print(a)
if __name__ == "__main__":
main()
| false | 23.611111 |
[
"-class UnionFind(object):",
"- def __init__(self, n=1):",
"- self.par = [i for i in range(n)]",
"- self.rank = [0 for _ in range(n)]",
"- self.size = [1 for _ in range(n)]",
"+class UnionFind:",
"+ def __init__(self, n):",
"+ self.n = n",
"+ self.parents = [-1] * n",
"- \"\"\"",
"- x が属するグループを探索",
"- \"\"\"",
"- # xが根だったら自分自身をreturnする",
"- if self.par[x] == x:",
"+ if self.parents[x] < 0:",
"- self.par[x] = self.find(self.par[x])",
"- return self.par[x]",
"+ self.parents[x] = self.find(self.parents[x])",
"+ return self.parents[x]",
"- \"\"\"",
"- x と y のグループを結合",
"- \"\"\"",
"- if x != y:",
"- if self.rank[x] < self.rank[y]:",
"- x, y = y, x",
"- if self.rank[x] == self.rank[y]:",
"- self.rank[x] += 1",
"- self.par[y] = x",
"- self.size[x] += self.size[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 is_same(self, x, y):",
"- \"\"\"",
"- x と y が同じグループかどうか",
"- \"\"\"",
"+ def same(self, x, y):",
"- def get_size(self, x):",
"- \"\"\"",
"- x が属するグループの要素数",
"- \"\"\"",
"- x = self.find(x)",
"- return self.size[x]",
"+ def size(self, x):",
"+ return -self.parents[self.find(x)]",
"- A = [None] * M",
"- B = [None] * M",
"- for i in range(M):",
"- A[i], B[i] = list(map(int, input().split()))",
"+ bridges = []",
"+ for _ in range(M):",
"+ A, B = list(map(int, input().split()))",
"+ A -= 1",
"+ B -= 1",
"+ bridges.append((A, B))",
"+ ans = [0] * M",
"+ ans[M - 1] = N * (N - 1) // 2",
"- ans = [None] * M",
"- ans[M - 1] = N * (N - 1) // 2",
"- x = A[i] - 1",
"- y = B[i] - 1",
"- # 辺でつなげても元々同じグループに属していた場合、変化はしない",
"- if uni.is_same(x, y):",
"+ a, b = bridges[i]",
"+ if not uni.same(a, b):",
"+ ans[i - 1] = ans[i] - (uni.size(a) * uni.size(b))",
"+ uni.union(a, b)",
"+ else:",
"- else:",
"- ans[i - 1] = ans[i] - (uni.get_size(x) * uni.get_size(y))",
"- uni.union(x, y)",
"-main()",
"+if __name__ == \"__main__\":",
"+ main()"
] | false | 0.042429 | 0.043977 | 0.964788 |
[
"s260353744",
"s171621628"
] |
u761320129
|
p03295
|
python
|
s452393962
|
s945570849
| 497 | 384 | 17,000 | 18,248 |
Accepted
|
Accepted
| 22.74 |
N,M = list(map(int,input().split()))
src = [tuple([int(x)-1 for x in input().split()]) for i in range(M)]
src.sort()
ans = 0
minb = N
for a,b in src:
if a >= minb:
ans += 1
minb = b
else:
minb = min(minb,b)
if src[-1][0] < minb:
ans += 1
print(ans)
|
N,M = list(map(int,input().split()))
src = [tuple(map(int,input().split())) for i in range(M)]
ans = 0
cut = -1
src.sort(key=lambda x:x[1])
for a,b in src:
if a < cut: continue
cut = b
ans += 1
print(ans)
| 15 | 11 | 296 | 221 |
N, M = list(map(int, input().split()))
src = [tuple([int(x) - 1 for x in input().split()]) for i in range(M)]
src.sort()
ans = 0
minb = N
for a, b in src:
if a >= minb:
ans += 1
minb = b
else:
minb = min(minb, b)
if src[-1][0] < minb:
ans += 1
print(ans)
|
N, M = list(map(int, input().split()))
src = [tuple(map(int, input().split())) for i in range(M)]
ans = 0
cut = -1
src.sort(key=lambda x: x[1])
for a, b in src:
if a < cut:
continue
cut = b
ans += 1
print(ans)
| false | 26.666667 |
[
"-src = [tuple([int(x) - 1 for x in input().split()]) for i in range(M)]",
"-src.sort()",
"+src = [tuple(map(int, input().split())) for i in range(M)]",
"-minb = N",
"+cut = -1",
"+src.sort(key=lambda x: x[1])",
"- if a >= minb:",
"- ans += 1",
"- minb = b",
"- else:",
"- minb = min(minb, b)",
"-if src[-1][0] < minb:",
"+ if a < cut:",
"+ continue",
"+ cut = b"
] | false | 0.041764 | 0.036529 | 1.143326 |
[
"s452393962",
"s945570849"
] |
u179169725
|
p03038
|
python
|
s126659522
|
s041034729
| 763 | 671 | 51,476 | 44,292 |
Accepted
|
Accepted
| 12.06 |
# https://atcoder.jp/contests/abc127/tasks/abc127_d
# 難しいこと考えすぎないこと。数字を書き換えるとは言ってるけどCjをBj枚追加して大きい方からN枚取るのが最適
# 具体的にBj枚追加していくと死ぬので、枚数はタプルでその数とともに保持しておく
import sys
read = sys.stdin.readline
def read_ints():
return list(map(int, read().split()))
def read_tuple(H):
'''
H is number of rows
'''
ret = []
for _ in range(H):
ret.append(tuple(map(int, read().split())))
return ret
from collections import Counter
N, M = read_ints()
A = read_ints()
BC = read_tuple(M)
cnter = Counter(A)
for b, c in BC:
cnter[c] += b
num_and_cnt = list(cnter.items())
num_and_cnt.sort(reverse=True)
ans = 0
total = 0
for num, cnt in num_and_cnt:
if total + cnt <= N:
total += cnt
ans += num * cnt
else:
while total < N:
ans += num
total += 1
print(ans)
|
import sys
sys.setrecursionlimit(1 << 25)
read = sys.stdin.readline
ra = range
enu = enumerate
def read_ints():
return list(map(int, read().split()))
def read_a_int():
return int(read())
def read_tuple(H):
'''
H is number of rows
'''
ret = []
for _ in range(H):
ret.append(tuple(map(int, read().split())))
return ret
def read_col(H):
'''
H is number of rows
A列、B列が与えられるようなとき
ex1)A,B=read_col(H) ex2) A,=read_col(H) #一列の場合
'''
ret = []
for _ in range(H):
ret.append(list(map(int, read().split())))
return tuple(map(list, list(zip(*ret))))
def read_matrix(H):
'''
H is number of rows
'''
ret = []
for _ in range(H):
ret.append(list(map(int, read().split())))
return ret
# return [list(map(int, read().split())) for _ in range(H)] # 内包表記はpypyでは遅いため
MOD = 10**9 + 7
INF = 2**31 # 2147483648 > 10**9
# default import
from collections import defaultdict, Counter, deque
from operator import itemgetter
from itertools import product, permutations, combinations
from bisect import bisect_left, bisect_right # , insort_left, insort_right
# https://atcoder.jp/contests/abc127/tasks/abc127_d
# わからん... データ構造で殴ります...
# いや、書き換えるっていうのは追加するっていうのと同じ意味じゃない？
# カードの枚数が多いから追加するのも大変→カードの枚数で管理しよう
N, M = read_ints()
A = read_ints()
A_cnt = Counter(A)
for _ in ra(M):
b, c = read_ints()
A_cnt[c] += b
tmp = list(A_cnt.items())
tmp.sort(key=lambda x: x[0], reverse=True)
ans = 0
cnt = 0
for k, v in tmp:
while v > 0 and cnt < N:
ans += k
v -= 1
cnt += 1
if cnt == N:
break
print(ans)
| 49 | 82 | 885 | 1,722 |
# https://atcoder.jp/contests/abc127/tasks/abc127_d
# 難しいこと考えすぎないこと。数字を書き換えるとは言ってるけどCjをBj枚追加して大きい方からN枚取るのが最適
# 具体的にBj枚追加していくと死ぬので、枚数はタプルでその数とともに保持しておく
import sys
read = sys.stdin.readline
def read_ints():
return list(map(int, read().split()))
def read_tuple(H):
"""
H is number of rows
"""
ret = []
for _ in range(H):
ret.append(tuple(map(int, read().split())))
return ret
from collections import Counter
N, M = read_ints()
A = read_ints()
BC = read_tuple(M)
cnter = Counter(A)
for b, c in BC:
cnter[c] += b
num_and_cnt = list(cnter.items())
num_and_cnt.sort(reverse=True)
ans = 0
total = 0
for num, cnt in num_and_cnt:
if total + cnt <= N:
total += cnt
ans += num * cnt
else:
while total < N:
ans += num
total += 1
print(ans)
|
import sys
sys.setrecursionlimit(1 << 25)
read = sys.stdin.readline
ra = range
enu = enumerate
def read_ints():
return list(map(int, read().split()))
def read_a_int():
return int(read())
def read_tuple(H):
"""
H is number of rows
"""
ret = []
for _ in range(H):
ret.append(tuple(map(int, read().split())))
return ret
def read_col(H):
"""
H is number of rows
A列、B列が与えられるようなとき
ex1)A,B=read_col(H) ex2) A,=read_col(H) #一列の場合
"""
ret = []
for _ in range(H):
ret.append(list(map(int, read().split())))
return tuple(map(list, list(zip(*ret))))
def read_matrix(H):
"""
H is number of rows
"""
ret = []
for _ in range(H):
ret.append(list(map(int, read().split())))
return ret
# return [list(map(int, read().split())) for _ in range(H)] # 内包表記はpypyでは遅いため
MOD = 10**9 + 7
INF = 2**31 # 2147483648 > 10**9
# default import
from collections import defaultdict, Counter, deque
from operator import itemgetter
from itertools import product, permutations, combinations
from bisect import bisect_left, bisect_right # , insort_left, insort_right
# https://atcoder.jp/contests/abc127/tasks/abc127_d
# わからん... データ構造で殴ります...
# いや、書き換えるっていうのは追加するっていうのと同じ意味じゃない？
# カードの枚数が多いから追加するのも大変→カードの枚数で管理しよう
N, M = read_ints()
A = read_ints()
A_cnt = Counter(A)
for _ in ra(M):
b, c = read_ints()
A_cnt[c] += b
tmp = list(A_cnt.items())
tmp.sort(key=lambda x: x[0], reverse=True)
ans = 0
cnt = 0
for k, v in tmp:
while v > 0 and cnt < N:
ans += k
v -= 1
cnt += 1
if cnt == N:
break
print(ans)
| false | 40.243902 |
[
"-# https://atcoder.jp/contests/abc127/tasks/abc127_d",
"-# 難しいこと考えすぎないこと。数字を書き換えるとは言ってるけどCjをBj枚追加して大きい方からN枚取るのが最適",
"-# 具体的にBj枚追加していくと死ぬので、枚数はタプルでその数とともに保持しておく",
"+sys.setrecursionlimit(1 << 25)",
"+ra = range",
"+enu = enumerate",
"+",
"+",
"+def read_a_int():",
"+ return int(read())",
"-from collections import Counter",
"+def read_col(H):",
"+ \"\"\"",
"+ H is number of rows",
"+ A列、B列が与えられるようなとき",
"+ ex1)A,B=read_col(H) ex2) A,=read_col(H) #一列の場合",
"+ \"\"\"",
"+ ret = []",
"+ for _ in range(H):",
"+ ret.append(list(map(int, read().split())))",
"+ return tuple(map(list, list(zip(*ret))))",
"+",
"+def read_matrix(H):",
"+ \"\"\"",
"+ H is number of rows",
"+ \"\"\"",
"+ ret = []",
"+ for _ in range(H):",
"+ ret.append(list(map(int, read().split())))",
"+ return ret",
"+ # return [list(map(int, read().split())) for _ in range(H)] # 内包表記はpypyでは遅いため",
"+",
"+",
"+MOD = 10**9 + 7",
"+INF = 2**31 # 2147483648 > 10**9",
"+# default import",
"+from collections import defaultdict, Counter, deque",
"+from operator import itemgetter",
"+from itertools import product, permutations, combinations",
"+from bisect import bisect_left, bisect_right # , insort_left, insort_right",
"+",
"+# https://atcoder.jp/contests/abc127/tasks/abc127_d",
"+# わからん... データ構造で殴ります...",
"+# いや、書き換えるっていうのは追加するっていうのと同じ意味じゃない？",
"+# カードの枚数が多いから追加するのも大変→カードの枚数で管理しよう",
"-BC = read_tuple(M)",
"-cnter = Counter(A)",
"-for b, c in BC:",
"- cnter[c] += b",
"-num_and_cnt = list(cnter.items())",
"-num_and_cnt.sort(reverse=True)",
"+A_cnt = Counter(A)",
"+for _ in ra(M):",
"+ b, c = read_ints()",
"+ A_cnt[c] += b",
"+tmp = list(A_cnt.items())",
"+tmp.sort(key=lambda x: x[0], reverse=True)",
"-total = 0",
"-for num, cnt in num_and_cnt:",
"- if total + cnt <= N:",
"- total += cnt",
"- ans += num * cnt",
"- else:",
"- while total < N:",
"- ans += num",
"- total += 1",
"+cnt = 0",
"+for k, v in tmp:",
"+ while v > 0 and cnt < N:",
"+ ans += k",
"+ v -= 1",
"+ cnt += 1",
"+ if cnt == N:",
"+ break"
] | false | 0.044257 | 0.04423 | 1.000596 |
[
"s126659522",
"s041034729"
] |
u038408819
|
p02881
|
python
|
s695388203
|
s264849691
| 173 | 148 | 2,940 | 3,060 |
Accepted
|
Accepted
| 14.45 |
N = int(eval(input()))
N2 = N ** (1 / 2)
ans = float('Inf')
for i in range(1, int(N2) + 1):
if N % i == 0:
a = i + N // i - 2
if ans > a:
ans = a
print(ans)
|
N = int(eval(input()))
N_2 = int(N ** 0.5)
ans = float('Inf')
for i in range(1, N_2 + 1):
if N % i == 0:
s = i + N / i - 2
ans = min(ans, int(s))
print(ans)
| 9 | 8 | 190 | 177 |
N = int(eval(input()))
N2 = N ** (1 / 2)
ans = float("Inf")
for i in range(1, int(N2) + 1):
if N % i == 0:
a = i + N // i - 2
if ans > a:
ans = a
print(ans)
|
N = int(eval(input()))
N_2 = int(N**0.5)
ans = float("Inf")
for i in range(1, N_2 + 1):
if N % i == 0:
s = i + N / i - 2
ans = min(ans, int(s))
print(ans)
| false | 11.111111 |
[
"-N2 = N ** (1 / 2)",
"+N_2 = int(N**0.5)",
"-for i in range(1, int(N2) + 1):",
"+for i in range(1, N_2 + 1):",
"- a = i + N // i - 2",
"- if ans > a:",
"- ans = a",
"+ s = i + N / i - 2",
"+ ans = min(ans, int(s))"
] | false | 0.050294 | 0.049806 | 1.009806 |
[
"s695388203",
"s264849691"
] |
u048773461
|
p02733
|
python
|
s886343557
|
s786996368
| 1,423 | 843 | 3,676 | 86,364 |
Accepted
|
Accepted
| 40.76 |
def main():
from itertools import product
import sys
sys.setrecursionlimit(10**6)
readline = sys.stdin.readline
ints = lambda: list(map(int, readline().split()))
floats = lambda: list(map(float, readline().split()))
lli = lambda I, J: [[0] * J for _ in range(I)]
mod = 10**9+7
h, w, k = ints()
ans = h + w
s = [list(map(int, eval(input()))) for _ in range(h)]
for comb in product([False, True], repeat=h - 1):
divs = 0
a = [s[0][:]]
for row, isd in zip(s[1:], comb):
if isd:
a += [row[:]]
divs += 1
else:
for i in range(w):
a[divs][i] += row[i]
dh = divs + 1
ta = [list(i) for i in zip(*a)]
currow = ta[0]
imp = False
for row in ta[1:]:
if any([i > k for i in currow]):
imp = True
break
else:
temp = [i + j for i, j in zip(currow, row)]
if any([i > k for i in temp]):
currow = row
divs += 1
else:
currow = temp
if not imp:
ans = min(ans, divs)
print(ans)
if __name__ == '__main__':
main()
|
def main():
from collections import Counter
from collections import defaultdict
from collections import deque
from itertools import accumulate
from itertools import combinations
from itertools import permutations
from itertools import product
import sys
sys.setrecursionlimit(10**6)
readline = sys.stdin.readline
ints = lambda: list(map(int, readline().split()))
floats = lambda: list(map(float, readline().split()))
lli = lambda I, J: [[0] * J for _ in range(I)]
mod = 10**9+7
h, w, k = ints()
ans = h + w
s = [list(map(int, eval(input()))) for _ in range(h)]
for comb in product([False, True], repeat=h - 1):
divs = 0
a = [s[0][:]]
for row, isd in zip(s[1:], comb):
if isd:
a += [row[:]]
divs += 1
else:
for i in range(w):
a[divs][i] += row[i]
dh = divs + 1
ta = [list(i) for i in zip(*a)]
currow = ta[0]
imp = False
for row in ta[1:]:
if any([i > k for i in currow]):
imp = True
break
else:
temp = [i + j for i, j in zip(currow, row)]
if any([i > k for i in temp]):
currow = row
divs += 1
else:
currow = temp
if not imp:
ans = min(ans, divs)
print(ans)
if __name__ == '__main__':
main()
| 44 | 50 | 1,113 | 1,332 |
def main():
from itertools import product
import sys
sys.setrecursionlimit(10**6)
readline = sys.stdin.readline
ints = lambda: list(map(int, readline().split()))
floats = lambda: list(map(float, readline().split()))
lli = lambda I, J: [[0] * J for _ in range(I)]
mod = 10**9 + 7
h, w, k = ints()
ans = h + w
s = [list(map(int, eval(input()))) for _ in range(h)]
for comb in product([False, True], repeat=h - 1):
divs = 0
a = [s[0][:]]
for row, isd in zip(s[1:], comb):
if isd:
a += [row[:]]
divs += 1
else:
for i in range(w):
a[divs][i] += row[i]
dh = divs + 1
ta = [list(i) for i in zip(*a)]
currow = ta[0]
imp = False
for row in ta[1:]:
if any([i > k for i in currow]):
imp = True
break
else:
temp = [i + j for i, j in zip(currow, row)]
if any([i > k for i in temp]):
currow = row
divs += 1
else:
currow = temp
if not imp:
ans = min(ans, divs)
print(ans)
if __name__ == "__main__":
main()
|
def main():
from collections import Counter
from collections import defaultdict
from collections import deque
from itertools import accumulate
from itertools import combinations
from itertools import permutations
from itertools import product
import sys
sys.setrecursionlimit(10**6)
readline = sys.stdin.readline
ints = lambda: list(map(int, readline().split()))
floats = lambda: list(map(float, readline().split()))
lli = lambda I, J: [[0] * J for _ in range(I)]
mod = 10**9 + 7
h, w, k = ints()
ans = h + w
s = [list(map(int, eval(input()))) for _ in range(h)]
for comb in product([False, True], repeat=h - 1):
divs = 0
a = [s[0][:]]
for row, isd in zip(s[1:], comb):
if isd:
a += [row[:]]
divs += 1
else:
for i in range(w):
a[divs][i] += row[i]
dh = divs + 1
ta = [list(i) for i in zip(*a)]
currow = ta[0]
imp = False
for row in ta[1:]:
if any([i > k for i in currow]):
imp = True
break
else:
temp = [i + j for i, j in zip(currow, row)]
if any([i > k for i in temp]):
currow = row
divs += 1
else:
currow = temp
if not imp:
ans = min(ans, divs)
print(ans)
if __name__ == "__main__":
main()
| false | 12 |
[
"+ from collections import Counter",
"+ from collections import defaultdict",
"+ from collections import deque",
"+ from itertools import accumulate",
"+ from itertools import combinations",
"+ from itertools import permutations"
] | false | 0.042023 | 0.036887 | 1.13923 |
[
"s886343557",
"s786996368"
] |
u697696097
|
p02762
|
python
|
s708652744
|
s841768920
| 1,629 | 756 | 122,396 | 25,064 |
Accepted
|
Accepted
| 53.59 |
import sys
from io import StringIO
import unittest
class UnionFind():
# 作りたい要素数nで初期化
# 使用するインスタンス変数の初期化
def __init__(self, n):
self.n = n
# root[x]<0ならそのノードが根かつその値が木の要素数
# rootノードでその木の要素数を記録する
self.root = [-1]*(n+1)
# 木をくっつける時にアンバランスにならないように調整する
self.rnk = [0]*(n+1)
# ノードxのrootノードを見つける
def Find_Root(self, x):
if(self.root[x] < 0):
return x
else:
# ここで代入しておくことで、後の繰り返しを避ける
self.root[x] = self.Find_Root(self.root[x])
return self.root[x]
# 木の併合、入力は併合したい各ノード
def Unite(self, x, y):
# 入力ノードのrootノードを見つける
x = self.Find_Root(x)
y = self.Find_Root(y)
# すでに同じ木に属していた場合
if(x == y):
return
# 違う木に属していた場合rnkを見てくっつける方を決める
elif(self.rnk[x] > self.rnk[y]):
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
# rnkが同じ（深さに差がない場合）は1増やす
if(self.rnk[x] == self.rnk[y]):
self.rnk[y] += 1
# xとyが同じグループに属するか判断
def isSameGroup(self, x, y):
return self.Find_Root(x) == self.Find_Root(y)
# ノードxが属する木のサイズを返す
def Count(self, x):
return -self.root[self.Find_Root(x)]
def resolve():
n,m,k=list(map(int,input().strip().split()))
uf = UnionFind(n)
res=[[] for i in range(n)]
frd=[0 for i in range(n)]
blk=[0 for i in range(n)]
for i in range(m):
a,b=list(map(int,input().strip().split()))
a-=1
b-=1
uf.Unite(a,b)
frd[a]+=1
frd[b]+=1
for i in range(k):
a,b=list(map(int,input().strip().split()))
a-=1
b-=1
if uf.isSameGroup(a,b):
blk[a]+=1
blk[b]+=1
rescnt=[]
for i in range(n):
ri=uf.Count(i)-1-blk[i]-frd[i]
rescnt.append(str(ri))
##rescnt.append(str(n-uf.size(i)-len(blk[i])))
print((" ".join(rescnt)))
resolve()
|
import sys
from io import StringIO
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
import unittest
class UnionFind():
# 作りたい要素数nで初期化
# 使用するインスタンス変数の初期化
def __init__(self, n):
self.n = n
# root[x]<0ならそのノードが根かつその値が木の要素数
# rootノードでその木の要素数を記録する
self.root = [-1]*(n+1)
# 木をくっつける時にアンバランスにならないように調整する
self.rnk = [0]*(n+1)
# ノードxのrootノードを見つける
def Find_Root(self, x):
if(self.root[x] < 0):
return x
else:
# ここで代入しておくことで、後の繰り返しを避ける
self.root[x] = self.Find_Root(self.root[x])
return self.root[x]
# 木の併合、入力は併合したい各ノード
def Unite(self, x, y):
# 入力ノードのrootノードを見つける
x = self.Find_Root(x)
y = self.Find_Root(y)
# すでに同じ木に属していた場合
if(x == y):
return
# 違う木に属していた場合rnkを見てくっつける方を決める
elif(self.rnk[x] > self.rnk[y]):
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
# rnkが同じ（深さに差がない場合）は1増やす
if(self.rnk[x] == self.rnk[y]):
self.rnk[y] += 1
# xとyが同じグループに属するか判断
def isSameGroup(self, x, y):
return self.Find_Root(x) == self.Find_Root(y)
# ノードxが属する木のサイズを返す
def Count(self, x):
return -self.root[self.Find_Root(x)]
def resolve():
n,m,k=list(map(int, readline().split()))
#list(map(int,input().strip().split()))
uf = UnionFind(n)
res=[[] for i in range(n)]
frd=[0 for i in range(n)]
blk=[0 for i in range(n)]
for i in range(m):
#a,b=list(map(int,input().strip().split()))
a,b=list(map(int, readline().split()))
a-=1
b-=1
uf.Unite(a,b)
frd[a]+=1
frd[b]+=1
for i in range(k):
#a,b=list(map(int,input().strip().split()))
a,b=list(map(int, readline().split()))
a-=1
b-=1
if uf.isSameGroup(a,b):
blk[a]+=1
blk[b]+=1
rescnt=[]
for i in range(n):
ri=uf.Count(i)-1-blk[i]-frd[i]
rescnt.append(str(ri))
##rescnt.append(str(n-uf.size(i)-len(blk[i])))
print((" ".join(rescnt)))
resolve()
| 85 | 91 | 2,144 | 2,373 |
import sys
from io import StringIO
import unittest
class UnionFind:
# 作りたい要素数nで初期化
# 使用するインスタンス変数の初期化
def __init__(self, n):
self.n = n
# root[x]<0ならそのノードが根かつその値が木の要素数
# rootノードでその木の要素数を記録する
self.root = [-1] * (n + 1)
# 木をくっつける時にアンバランスにならないように調整する
self.rnk = [0] * (n + 1)
# ノードxのrootノードを見つける
def Find_Root(self, x):
if self.root[x] < 0:
return x
else:
# ここで代入しておくことで、後の繰り返しを避ける
self.root[x] = self.Find_Root(self.root[x])
return self.root[x]
# 木の併合、入力は併合したい各ノード
def Unite(self, x, y):
# 入力ノードのrootノードを見つける
x = self.Find_Root(x)
y = self.Find_Root(y)
# すでに同じ木に属していた場合
if x == y:
return
# 違う木に属していた場合rnkを見てくっつける方を決める
elif self.rnk[x] > self.rnk[y]:
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
# rnkが同じ（深さに差がない場合）は1増やす
if self.rnk[x] == self.rnk[y]:
self.rnk[y] += 1
# xとyが同じグループに属するか判断
def isSameGroup(self, x, y):
return self.Find_Root(x) == self.Find_Root(y)
# ノードxが属する木のサイズを返す
def Count(self, x):
return -self.root[self.Find_Root(x)]
def resolve():
n, m, k = list(map(int, input().strip().split()))
uf = UnionFind(n)
res = [[] for i in range(n)]
frd = [0 for i in range(n)]
blk = [0 for i in range(n)]
for i in range(m):
a, b = list(map(int, input().strip().split()))
a -= 1
b -= 1
uf.Unite(a, b)
frd[a] += 1
frd[b] += 1
for i in range(k):
a, b = list(map(int, input().strip().split()))
a -= 1
b -= 1
if uf.isSameGroup(a, b):
blk[a] += 1
blk[b] += 1
rescnt = []
for i in range(n):
ri = uf.Count(i) - 1 - blk[i] - frd[i]
rescnt.append(str(ri))
##rescnt.append(str(n-uf.size(i)-len(blk[i])))
print((" ".join(rescnt)))
resolve()
|
import sys
from io import StringIO
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
import unittest
class UnionFind:
# 作りたい要素数nで初期化
# 使用するインスタンス変数の初期化
def __init__(self, n):
self.n = n
# root[x]<0ならそのノードが根かつその値が木の要素数
# rootノードでその木の要素数を記録する
self.root = [-1] * (n + 1)
# 木をくっつける時にアンバランスにならないように調整する
self.rnk = [0] * (n + 1)
# ノードxのrootノードを見つける
def Find_Root(self, x):
if self.root[x] < 0:
return x
else:
# ここで代入しておくことで、後の繰り返しを避ける
self.root[x] = self.Find_Root(self.root[x])
return self.root[x]
# 木の併合、入力は併合したい各ノード
def Unite(self, x, y):
# 入力ノードのrootノードを見つける
x = self.Find_Root(x)
y = self.Find_Root(y)
# すでに同じ木に属していた場合
if x == y:
return
# 違う木に属していた場合rnkを見てくっつける方を決める
elif self.rnk[x] > self.rnk[y]:
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
# rnkが同じ（深さに差がない場合）は1増やす
if self.rnk[x] == self.rnk[y]:
self.rnk[y] += 1
# xとyが同じグループに属するか判断
def isSameGroup(self, x, y):
return self.Find_Root(x) == self.Find_Root(y)
# ノードxが属する木のサイズを返す
def Count(self, x):
return -self.root[self.Find_Root(x)]
def resolve():
n, m, k = list(map(int, readline().split()))
# list(map(int,input().strip().split()))
uf = UnionFind(n)
res = [[] for i in range(n)]
frd = [0 for i in range(n)]
blk = [0 for i in range(n)]
for i in range(m):
# a,b=list(map(int,input().strip().split()))
a, b = list(map(int, readline().split()))
a -= 1
b -= 1
uf.Unite(a, b)
frd[a] += 1
frd[b] += 1
for i in range(k):
# a,b=list(map(int,input().strip().split()))
a, b = list(map(int, readline().split()))
a -= 1
b -= 1
if uf.isSameGroup(a, b):
blk[a] += 1
blk[b] += 1
rescnt = []
for i in range(n):
ri = uf.Count(i) - 1 - blk[i] - frd[i]
rescnt.append(str(ri))
##rescnt.append(str(n-uf.size(i)-len(blk[i])))
print((" ".join(rescnt)))
resolve()
| false | 6.593407 |
[
"+",
"+read = sys.stdin.buffer.read",
"+readline = sys.stdin.buffer.readline",
"+readlines = sys.stdin.buffer.readlines",
"- n, m, k = list(map(int, input().strip().split()))",
"+ n, m, k = list(map(int, readline().split()))",
"+ # list(map(int,input().strip().split()))",
"- a, b = list(map(int, input().strip().split()))",
"+ # a,b=list(map(int,input().strip().split()))",
"+ a, b = list(map(int, readline().split()))",
"- a, b = list(map(int, input().strip().split()))",
"+ # a,b=list(map(int,input().strip().split()))",
"+ a, b = list(map(int, readline().split()))"
] | false | 0.03917 | 0.067874 | 0.577094 |
[
"s708652744",
"s841768920"
] |
u067299340
|
p00022
|
python
|
s486892717
|
s130928034
| 40 | 20 | 4,360 | 4,436 |
Accepted
|
Accepted
| 50 |
while 1:
n=eval(input())
if n==0:break
r=[eval(input())for i in range(n)]
#print r
for i in range(1,n):
r[i]=max(r[i-1]+r[i],r[i])
#print r
print(max(r))
|
while 1:
n=eval(input())
if n==0:break
r=[int(input())for i in range(n)]
for i in range(1,n):
r[i]=max(r[i-1]+r[i],r[i])
print(max(r))
| 9 | 7 | 160 | 144 |
while 1:
n = eval(input())
if n == 0:
break
r = [eval(input()) for i in range(n)]
# print r
for i in range(1, n):
r[i] = max(r[i - 1] + r[i], r[i])
# print r
print(max(r))
|
while 1:
n = eval(input())
if n == 0:
break
r = [int(input()) for i in range(n)]
for i in range(1, n):
r[i] = max(r[i - 1] + r[i], r[i])
print(max(r))
| false | 22.222222 |
[
"- r = [eval(input()) for i in range(n)]",
"- # print r",
"+ r = [int(input()) for i in range(n)]",
"- # print r"
] | false | 0.062429 | 0.036576 | 1.706852 |
[
"s486892717",
"s130928034"
] |
u479788474
|
p02657
|
python
|
s146964321
|
s334962653
| 28 | 25 | 9,056 | 8,916 |
Accepted
|
Accepted
| 10.71 |
# 169A
# 1.入力を受け取ること
# ex:[2 5] -> a=2, b=5 みたいにしないといけない
a, b = list(map(int, input().split()))
# 2.目的通りの計算をする
# ex：2つの整数AとBの掛け算をやる
answer = a * b
# 3.計算の結果を出力する
print(answer)
|
A, B = input().split()
total = int(A) * int(B)
print(total)
| 14 | 5 | 188 | 66 |
# 169A
# 1.入力を受け取ること
# ex:[2 5] -> a=2, b=5 みたいにしないといけない
a, b = list(map(int, input().split()))
# 2.目的通りの計算をする
# ex：2つの整数AとBの掛け算をやる
answer = a * b
# 3.計算の結果を出力する
print(answer)
|
A, B = input().split()
total = int(A) * int(B)
print(total)
| false | 64.285714 |
[
"-# 169A",
"-# 1.入力を受け取ること",
"-# ex:[2 5] -> a=2, b=5 みたいにしないといけない",
"-a, b = list(map(int, input().split()))",
"-# 2.目的通りの計算をする",
"-# ex：2つの整数AとBの掛け算をやる",
"-answer = a * b",
"-# 3.計算の結果を出力する",
"-print(answer)",
"+A, B = input().split()",
"+total = int(A) * int(B)",
"+print(total)"
] | false | 0.095999 | 0.041744 | 2.29974 |
[
"s146964321",
"s334962653"
] |
u823513038
|
p02390
|
python
|
s269160818
|
s627526572
| 30 | 20 | 7,652 | 7,640 |
Accepted
|
Accepted
| 33.33 |
x = int(input())
print(int(x / 3600), int(x / 60 % 60), int(x % 60), sep = ':')
|
x = int(input())
print(x // 3600, x // 60 % 60, x % 60, sep = ':')
| 2 | 2 | 80 | 67 |
x = int(input())
print(int(x / 3600), int(x / 60 % 60), int(x % 60), sep=":")
|
x = int(input())
print(x // 3600, x // 60 % 60, x % 60, sep=":")
| false | 0 |
[
"-print(int(x / 3600), int(x / 60 % 60), int(x % 60), sep=\":\")",
"+print(x // 3600, x // 60 % 60, x % 60, sep=\":\")"
] | false | 0.074585 | 0.068675 | 1.086062 |
[
"s269160818",
"s627526572"
] |
u332385682
|
p03800
|
python
|
s768571059
|
s051199860
| 167 | 129 | 5,772 | 6,268 |
Accepted
|
Accepted
| 22.75 |
import sys
def debug(x, table):
for name, val in table.items():
if x is val:
print('DEBUG:{} -> {}'.format(name, val), file=sys.stderr)
return None
def solve():
N = int(input())
S = [True if i == 'o' else False for i in input()]
# debug(S, locals())
for i, j in [(False, False), (False, True), (True, False), (True, True)]:
pat = [i, j]
for k in range(2, N):
if pat[k - 1]:
if S[k - 1]:
pat.append(pat[k - 2])
else:
pat.append(not pat[k - 2])
else:
if S[k - 1]:
pat.append(not pat[k - 2])
else:
pat.append(pat[k - 2])
# debug(pat, locals())
for k in range(N):
if pat[k]:
if S[k] != is_same(pat, k, N):
break
else:
if S[k] == is_same(pat, k, N):
break
else:
ans = ['S' if pat[k] else 'W' for k in range(N)]
print(''.join(ans))
return None
print(-1)
def is_same(pat, i, N):
return pat[(i - 1) % N] == pat[(i + 1) % N]
if __name__ == '__main__':
solve()
|
import sys
from itertools import product
def debug(x, table):
for name, val in table.items():
if x is val:
print('DEBUG:{} -> {}'.format(name, val), file=sys.stderr)
return None
def solve():
N = int(input())
S = [0 if i == 'o' else 1 for i in input()]
for i, j in product(range(2), repeat=2):
pat = [i, j] + [0]*(N - 2)
for k in range(2, N):
pat[k] = (S[k - 1] - (pat[k - 1] + pat[k - 2])) % 2
if S[-1] != (pat[0] + pat[-1] + pat[-2]) % 2:
continue
if S[0] != (pat[1] + pat[0] + pat[-1]) % 2:
continue
ans = ['S' if pat[k] == 0 else 'W' for k in range(N)]
print(''.join(ans))
return None
print(-1)
if __name__ == '__main__':
solve()
| 48 | 31 | 1,309 | 821 |
import sys
def debug(x, table):
for name, val in table.items():
if x is val:
print("DEBUG:{} -> {}".format(name, val), file=sys.stderr)
return None
def solve():
N = int(input())
S = [True if i == "o" else False for i in input()]
# debug(S, locals())
for i, j in [(False, False), (False, True), (True, False), (True, True)]:
pat = [i, j]
for k in range(2, N):
if pat[k - 1]:
if S[k - 1]:
pat.append(pat[k - 2])
else:
pat.append(not pat[k - 2])
else:
if S[k - 1]:
pat.append(not pat[k - 2])
else:
pat.append(pat[k - 2])
# debug(pat, locals())
for k in range(N):
if pat[k]:
if S[k] != is_same(pat, k, N):
break
else:
if S[k] == is_same(pat, k, N):
break
else:
ans = ["S" if pat[k] else "W" for k in range(N)]
print("".join(ans))
return None
print(-1)
def is_same(pat, i, N):
return pat[(i - 1) % N] == pat[(i + 1) % N]
if __name__ == "__main__":
solve()
|
import sys
from itertools import product
def debug(x, table):
for name, val in table.items():
if x is val:
print("DEBUG:{} -> {}".format(name, val), file=sys.stderr)
return None
def solve():
N = int(input())
S = [0 if i == "o" else 1 for i in input()]
for i, j in product(range(2), repeat=2):
pat = [i, j] + [0] * (N - 2)
for k in range(2, N):
pat[k] = (S[k - 1] - (pat[k - 1] + pat[k - 2])) % 2
if S[-1] != (pat[0] + pat[-1] + pat[-2]) % 2:
continue
if S[0] != (pat[1] + pat[0] + pat[-1]) % 2:
continue
ans = ["S" if pat[k] == 0 else "W" for k in range(N)]
print("".join(ans))
return None
print(-1)
if __name__ == "__main__":
solve()
| false | 35.416667 |
[
"+from itertools import product",
"- S = [True if i == \"o\" else False for i in input()]",
"- # debug(S, locals())",
"- for i, j in [(False, False), (False, True), (True, False), (True, True)]:",
"- pat = [i, j]",
"+ S = [0 if i == \"o\" else 1 for i in input()]",
"+ for i, j in product(range(2), repeat=2):",
"+ pat = [i, j] + [0] * (N - 2)",
"- if pat[k - 1]:",
"- if S[k - 1]:",
"- pat.append(pat[k - 2])",
"- else:",
"- pat.append(not pat[k - 2])",
"- else:",
"- if S[k - 1]:",
"- pat.append(not pat[k - 2])",
"- else:",
"- pat.append(pat[k - 2])",
"- # debug(pat, locals())",
"- for k in range(N):",
"- if pat[k]:",
"- if S[k] != is_same(pat, k, N):",
"- break",
"- else:",
"- if S[k] == is_same(pat, k, N):",
"- break",
"- else:",
"- ans = [\"S\" if pat[k] else \"W\" for k in range(N)]",
"- print(\"\".join(ans))",
"- return None",
"+ pat[k] = (S[k - 1] - (pat[k - 1] + pat[k - 2])) % 2",
"+ if S[-1] != (pat[0] + pat[-1] + pat[-2]) % 2:",
"+ continue",
"+ if S[0] != (pat[1] + pat[0] + pat[-1]) % 2:",
"+ continue",
"+ ans = [\"S\" if pat[k] == 0 else \"W\" for k in range(N)]",
"+ print(\"\".join(ans))",
"+ return None",
"-",
"-",
"-def is_same(pat, i, N):",
"- return pat[(i - 1) % N] == pat[(i + 1) % N]"
] | false | 0.00842 | 0.072249 | 0.116546 |
[
"s768571059",
"s051199860"
] |
u576432509
|
p03487
|
python
|
s312092181
|
s203809102
| 185 | 98 | 16,760 | 18,164 |
Accepted
|
Accepted
| 47.03 |
n=int(eval(input()))
a=list(map(int,input().split()))
a.sort()
amax=a[-1]
amin=a[0]
s=[]
ai=a[0]
acnt=-1
for i in range(n):
if a[i]>ai:
s.append([ai,acnt+1])
acnt=0
ai=a[i]
else:
acnt=acnt+1
s.append([ai,acnt+1])
# print(s)
dn=0
for i in range(len(s)):
ni=s[i][1]
if ni>s[i][0]:
dn=dn+(ni-s[i][0])
elif ni<s[i][0]:
dn=dn+ni
print(dn)
|
n=int(eval(input()))
a=list(map(int,input().split()))
d=dict()
for i in range(n):
if a[i] in d:
d[a[i]]=d[a[i]]+1
else:
d[a[i]]=1
xsum=0
for x in list(d.keys()):
if d[x]<x:
xsum=xsum+d[x]
elif d[x]>x:
xsum=xsum+d[x]-x
print(xsum)
| 30 | 19 | 449 | 303 |
n = int(eval(input()))
a = list(map(int, input().split()))
a.sort()
amax = a[-1]
amin = a[0]
s = []
ai = a[0]
acnt = -1
for i in range(n):
if a[i] > ai:
s.append([ai, acnt + 1])
acnt = 0
ai = a[i]
else:
acnt = acnt + 1
s.append([ai, acnt + 1])
# print(s)
dn = 0
for i in range(len(s)):
ni = s[i][1]
if ni > s[i][0]:
dn = dn + (ni - s[i][0])
elif ni < s[i][0]:
dn = dn + ni
print(dn)
|
n = int(eval(input()))
a = list(map(int, input().split()))
d = dict()
for i in range(n):
if a[i] in d:
d[a[i]] = d[a[i]] + 1
else:
d[a[i]] = 1
xsum = 0
for x in list(d.keys()):
if d[x] < x:
xsum = xsum + d[x]
elif d[x] > x:
xsum = xsum + d[x] - x
print(xsum)
| false | 36.666667 |
[
"-a.sort()",
"-amax = a[-1]",
"-amin = a[0]",
"-s = []",
"-ai = a[0]",
"-acnt = -1",
"+d = dict()",
"- if a[i] > ai:",
"- s.append([ai, acnt + 1])",
"- acnt = 0",
"- ai = a[i]",
"+ if a[i] in d:",
"+ d[a[i]] = d[a[i]] + 1",
"- acnt = acnt + 1",
"-s.append([ai, acnt + 1])",
"-# print(s)",
"-dn = 0",
"-for i in range(len(s)):",
"- ni = s[i][1]",
"- if ni > s[i][0]:",
"- dn = dn + (ni - s[i][0])",
"- elif ni < s[i][0]:",
"- dn = dn + ni",
"-print(dn)",
"+ d[a[i]] = 1",
"+xsum = 0",
"+for x in list(d.keys()):",
"+ if d[x] < x:",
"+ xsum = xsum + d[x]",
"+ elif d[x] > x:",
"+ xsum = xsum + d[x] - x",
"+print(xsum)"
] | false | 0.036281 | 0.061158 | 0.593236 |
[
"s312092181",
"s203809102"
] |
u459150945
|
p02819
|
python
|
s468290675
|
s366333058
| 101 | 17 | 7,472 | 2,940 |
Accepted
|
Accepted
| 83.17 |
import math
X = int(eval(input()))
def get_primenumber(number):
prime_list = []
# 2からnumberまでの数字をsearch_listに入れる
search_list = list(range(2, number+1))
while True:
# search_listの先頭の値が√nの値を超えたら処理終了
if search_list[0] > math.sqrt(number):
# prime_listにsearch_listを結合
prime_list.extend(search_list)
break
else:
# search_listの先頭をprime_listに入れる
head_num = search_list[0]
prime_list.append(head_num)
# search_listの先頭をpopする
search_list.pop(0)
# head_numの倍数を取り除く
search_list = [num for num in search_list if num % head_num != 0]
return prime_list
prime_list = get_primenumber(100000)
left = 0
right = len(prime_list)-1
if X == 2:
print((int(2)))
elif X > 99991:
print((int(100003)))
else:
while left <= right:
mid = (left+right) // 2
if prime_list[mid] == X:
ans = prime_list[mid]
break
elif prime_list[mid] > X:
if prime_list[mid-1] < X:
ans = prime_list[mid]
break
else:
right = mid - 1
else:
if prime_list[mid+1] > X:
ans = prime_list[mid+1]
break
else:
left = mid + 1
print((int(ans)))
|
x = int(eval(input()))
while True:
i = 2
ok = True
while i * i <= x:
if x % i == 0:
ok = False
break
i += 1
if ok:
print(x)
break
x += 1
| 53 | 14 | 1,402 | 220 |
import math
X = int(eval(input()))
def get_primenumber(number):
prime_list = []
# 2からnumberまでの数字をsearch_listに入れる
search_list = list(range(2, number + 1))
while True:
# search_listの先頭の値が√nの値を超えたら処理終了
if search_list[0] > math.sqrt(number):
# prime_listにsearch_listを結合
prime_list.extend(search_list)
break
else:
# search_listの先頭をprime_listに入れる
head_num = search_list[0]
prime_list.append(head_num)
# search_listの先頭をpopする
search_list.pop(0)
# head_numの倍数を取り除く
search_list = [num for num in search_list if num % head_num != 0]
return prime_list
prime_list = get_primenumber(100000)
left = 0
right = len(prime_list) - 1
if X == 2:
print((int(2)))
elif X > 99991:
print((int(100003)))
else:
while left <= right:
mid = (left + right) // 2
if prime_list[mid] == X:
ans = prime_list[mid]
break
elif prime_list[mid] > X:
if prime_list[mid - 1] < X:
ans = prime_list[mid]
break
else:
right = mid - 1
else:
if prime_list[mid + 1] > X:
ans = prime_list[mid + 1]
break
else:
left = mid + 1
print((int(ans)))
|
x = int(eval(input()))
while True:
i = 2
ok = True
while i * i <= x:
if x % i == 0:
ok = False
break
i += 1
if ok:
print(x)
break
x += 1
| false | 73.584906 |
[
"-import math",
"-",
"-X = int(eval(input()))",
"-",
"-",
"-def get_primenumber(number):",
"- prime_list = []",
"- # 2からnumberまでの数字をsearch_listに入れる",
"- search_list = list(range(2, number + 1))",
"- while True:",
"- # search_listの先頭の値が√nの値を超えたら処理終了",
"- if search_list[0] > math.sqrt(number):",
"- # prime_listにsearch_listを結合",
"- prime_list.extend(search_list)",
"+x = int(eval(input()))",
"+while True:",
"+ i = 2",
"+ ok = True",
"+ while i * i <= x:",
"+ if x % i == 0:",
"+ ok = False",
"- else:",
"- # search_listの先頭をprime_listに入れる",
"- head_num = search_list[0]",
"- prime_list.append(head_num)",
"- # search_listの先頭をpopする",
"- search_list.pop(0)",
"- # head_numの倍数を取り除く",
"- search_list = [num for num in search_list if num % head_num != 0]",
"- return prime_list",
"-",
"-",
"-prime_list = get_primenumber(100000)",
"-left = 0",
"-right = len(prime_list) - 1",
"-if X == 2:",
"- print((int(2)))",
"-elif X > 99991:",
"- print((int(100003)))",
"-else:",
"- while left <= right:",
"- mid = (left + right) // 2",
"- if prime_list[mid] == X:",
"- ans = prime_list[mid]",
"- break",
"- elif prime_list[mid] > X:",
"- if prime_list[mid - 1] < X:",
"- ans = prime_list[mid]",
"- break",
"- else:",
"- right = mid - 1",
"- else:",
"- if prime_list[mid + 1] > X:",
"- ans = prime_list[mid + 1]",
"- break",
"- else:",
"- left = mid + 1",
"- print((int(ans)))",
"+ i += 1",
"+ if ok:",
"+ print(x)",
"+ break",
"+ x += 1"
] | false | 0.182225 | 0.036113 | 5.04594 |
[
"s468290675",
"s366333058"
] |
u519939795
|
p03447
|
python
|
s284718074
|
s949223102
| 19 | 17 | 3,060 | 2,940 |
Accepted
|
Accepted
| 10.53 |
x = int(eval(input()))
a = int(eval(input()))
b = int(eval(input()))
c = x - a
d = c%b
print(d)
|
x,a,b = [int(eval(input())) for i in range(3)]
print(((x-a)%b))
| 6 | 2 | 82 | 56 |
x = int(eval(input()))
a = int(eval(input()))
b = int(eval(input()))
c = x - a
d = c % b
print(d)
|
x, a, b = [int(eval(input())) for i in range(3)]
print(((x - a) % b))
| false | 66.666667 |
[
"-x = int(eval(input()))",
"-a = int(eval(input()))",
"-b = int(eval(input()))",
"-c = x - a",
"-d = c % b",
"-print(d)",
"+x, a, b = [int(eval(input())) for i in range(3)]",
"+print(((x - a) % b))"
] | false | 0.04445 | 0.147811 | 0.300724 |
[
"s284718074",
"s949223102"
] |
u182594853
|
p03835
|
python
|
s376603522
|
s879324533
| 1,901 | 1,643 | 2,940 | 2,940 |
Accepted
|
Accepted
| 13.57 |
k, s = list(map(int, input().split()))
count=0
for i in range(k+1):
for j in range(k+1):
t = s-i-j
if t <= k and t >= 0:
count += 1
else:
pass
print (count)
|
k, s = list(map(int, input().split()))
count=0
for i in range(k+1):
for j in range(k+1):
t = s-i-j
if t <= k and t >= 0:
count += 1
print (count)
| 10 | 8 | 212 | 179 |
k, s = list(map(int, input().split()))
count = 0
for i in range(k + 1):
for j in range(k + 1):
t = s - i - j
if t <= k and t >= 0:
count += 1
else:
pass
print(count)
|
k, s = list(map(int, input().split()))
count = 0
for i in range(k + 1):
for j in range(k + 1):
t = s - i - j
if t <= k and t >= 0:
count += 1
print(count)
| false | 20 |
[
"- else:",
"- pass"
] | false | 0.078586 | 0.041498 | 1.893729 |
[
"s376603522",
"s879324533"
] |
u065079240
|
p02598
|
python
|
s922121294
|
s680090824
| 1,920 | 1,631 | 31,052 | 30,988 |
Accepted
|
Accepted
| 15.05 |
import math
N,K=list(map(int,input().split()))
A=[int(x) for x in input().split()]
A=sorted(A)
left=0
right=max(A)
mid=max((left+right)//2,1)
while(right-left>=1):
numofcut=0
for i in range(N):
if A[i]%mid==0:
numofcut+=(A[i]//mid) -1
else:
numofcut+=A[i]//mid
#print(numofcut)
if numofcut>K:
left=mid+1
else:
right=mid
mid=max((left+right)//2,1)
if mid==1:
break
print(mid)
|
import math
N,K=list(map(int,input().split()))
A=[int(x) for x in input().split()]
A=sorted(A)
left=0
right=max(A)
mid=max((left+right)//2,1)
while(right-left>=1):
numofcut=0
for i in range(N):
numofcut+=math.ceil(A[i]/mid)-1
#print(numofcut)
if numofcut>K:
left=mid+1
else:
right=mid
mid=max((left+right)//2,1)
if mid==1:
break
print(mid)
| 25 | 22 | 491 | 421 |
import math
N, K = list(map(int, input().split()))
A = [int(x) for x in input().split()]
A = sorted(A)
left = 0
right = max(A)
mid = max((left + right) // 2, 1)
while right - left >= 1:
numofcut = 0
for i in range(N):
if A[i] % mid == 0:
numofcut += (A[i] // mid) - 1
else:
numofcut += A[i] // mid
# print(numofcut)
if numofcut > K:
left = mid + 1
else:
right = mid
mid = max((left + right) // 2, 1)
if mid == 1:
break
print(mid)
|
import math
N, K = list(map(int, input().split()))
A = [int(x) for x in input().split()]
A = sorted(A)
left = 0
right = max(A)
mid = max((left + right) // 2, 1)
while right - left >= 1:
numofcut = 0
for i in range(N):
numofcut += math.ceil(A[i] / mid) - 1
# print(numofcut)
if numofcut > K:
left = mid + 1
else:
right = mid
mid = max((left + right) // 2, 1)
if mid == 1:
break
print(mid)
| false | 12 |
[
"- if A[i] % mid == 0:",
"- numofcut += (A[i] // mid) - 1",
"- else:",
"- numofcut += A[i] // mid",
"+ numofcut += math.ceil(A[i] / mid) - 1"
] | false | 0.069879 | 0.035486 | 1.969212 |
[
"s922121294",
"s680090824"
] |
u017415492
|
p02995
|
python
|
s033334251
|
s269608034
| 39 | 36 | 5,436 | 5,048 |
Accepted
|
Accepted
| 7.69 |
import fractions
a,b,c,d=list(map(int,input().split()))
count=0
e=(c*d)//fractions.gcd(c,d)
D=[c,d,e]
f=[]
for i in D:
f.append((b//i)-((a-1)//i))
print((b-a+1-f[0]-f[1]+f[2]))
|
import fractions
a,b,c,d=list(map(int,input().split()))
e=(c*d)//fractions.gcd(c,d)
a=a-1
n1=a-(a//c + a//d - a//e)
n2=b-(b//c + b//d - b//e)
print((n2-n1))
| 10 | 8 | 180 | 156 |
import fractions
a, b, c, d = list(map(int, input().split()))
count = 0
e = (c * d) // fractions.gcd(c, d)
D = [c, d, e]
f = []
for i in D:
f.append((b // i) - ((a - 1) // i))
print((b - a + 1 - f[0] - f[1] + f[2]))
|
import fractions
a, b, c, d = list(map(int, input().split()))
e = (c * d) // fractions.gcd(c, d)
a = a - 1
n1 = a - (a // c + a // d - a // e)
n2 = b - (b // c + b // d - b // e)
print((n2 - n1))
| false | 20 |
[
"-count = 0",
"-D = [c, d, e]",
"-f = []",
"-for i in D:",
"- f.append((b // i) - ((a - 1) // i))",
"-print((b - a + 1 - f[0] - f[1] + f[2]))",
"+a = a - 1",
"+n1 = a - (a // c + a // d - a // e)",
"+n2 = b - (b // c + b // d - b // e)",
"+print((n2 - n1))"
] | false | 0.058898 | 0.135239 | 0.435508 |
[
"s033334251",
"s269608034"
] |
u506910932
|
p03087
|
python
|
s645014702
|
s125269806
| 579 | 484 | 11,348 | 13,040 |
Accepted
|
Accepted
| 16.41 |
import bisect
n, q = list(map(int, input().split()))
s = eval(input())
cnt = 0
apoint = []
cpoint = []
for i in range(len(s) - 1):
if s[i] + s[i + 1] == 'AC':
cnt += 1
apoint.append(i)
cpoint.append(i)
# print('cnt:', cnt)
# print('acpoint:', apoint)
for i in range(q):
l, r = list(map(int, input().split()))
l, r = l - 1, r - 1
left = bisect.bisect_left(apoint, l)
right = bisect.bisect_left(cpoint, r)
print((right - left))
|
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 i in range(Q):
l, r = list(map(int, input().split()))
print((t[r-1] - t[l-1]))
| 19 | 8 | 472 | 220 |
import bisect
n, q = list(map(int, input().split()))
s = eval(input())
cnt = 0
apoint = []
cpoint = []
for i in range(len(s) - 1):
if s[i] + s[i + 1] == "AC":
cnt += 1
apoint.append(i)
cpoint.append(i)
# print('cnt:', cnt)
# print('acpoint:', apoint)
for i in range(q):
l, r = list(map(int, input().split()))
l, r = l - 1, r - 1
left = bisect.bisect_left(apoint, l)
right = bisect.bisect_left(cpoint, r)
print((right - left))
|
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 i in range(Q):
l, r = list(map(int, input().split()))
print((t[r - 1] - t[l - 1]))
| false | 57.894737 |
[
"-import bisect",
"-",
"-n, q = list(map(int, input().split()))",
"-s = eval(input())",
"-cnt = 0",
"-apoint = []",
"-cpoint = []",
"-for i in range(len(s) - 1):",
"- if s[i] + s[i + 1] == \"AC\":",
"- cnt += 1",
"- apoint.append(i)",
"- cpoint.append(i)",
"-# print('cnt:', cnt)",
"-# print('acpoint:', apoint)",
"-for i in range(q):",
"+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 i in range(Q):",
"- l, r = l - 1, r - 1",
"- left = bisect.bisect_left(apoint, l)",
"- right = bisect.bisect_left(cpoint, r)",
"- print((right - left))",
"+ print((t[r - 1] - t[l - 1]))"
] | false | 0.04269 | 0.048525 | 0.879753 |
[
"s645014702",
"s125269806"
] |
u347640436
|
p02936
|
python
|
s074339529
|
s461274304
| 1,773 | 1,552 | 107,156 | 62,132 |
Accepted
|
Accepted
| 12.46 |
from collections import deque
def main():
_map, _input, _int = map, input, int
n, q = _map(_int, _input().split())
values = [0] * n
links = [[] for _ in range(n)]
for _ in range(n - 1):
a, b = _map(_int, _input().split())
links[a - 1].append(b - 1)
links[b - 1].append(a - 1)
for _ in range(q):
p, x = _map(_int, _input().split())
values[p - 1] += x
d = deque()
d.append((0, -1))
while len(d) != 0:
i, p = d.popleft()
for j in links[i]:
if j == p:
continue
values[j] += values[i]
d.append((j, i))
print((*values))
main()
|
from collections import deque
def main():
_map, _input, _int = map, input, int
n, q = _map(_int, _input().split())
values = [0] * n
links = [[] for _ in range(n)]
for _ in range(n - 1):
a, b = _map(_int, _input().split())
if a >= b:
return
links[a - 1].append(b - 1)
links[b - 1].append(a - 1)
for _ in range(q):
p, x = _map(_int, _input().split())
values[p - 1] += x
d = deque()
d.append((0, -1))
while len(d) != 0:
i, p = d.popleft()
for j in links[i]:
if j == p:
continue
values[j] += values[i]
d.append((j, i))
print((*values))
main()
| 24 | 26 | 616 | 646 |
from collections import deque
def main():
_map, _input, _int = map, input, int
n, q = _map(_int, _input().split())
values = [0] * n
links = [[] for _ in range(n)]
for _ in range(n - 1):
a, b = _map(_int, _input().split())
links[a - 1].append(b - 1)
links[b - 1].append(a - 1)
for _ in range(q):
p, x = _map(_int, _input().split())
values[p - 1] += x
d = deque()
d.append((0, -1))
while len(d) != 0:
i, p = d.popleft()
for j in links[i]:
if j == p:
continue
values[j] += values[i]
d.append((j, i))
print((*values))
main()
|
from collections import deque
def main():
_map, _input, _int = map, input, int
n, q = _map(_int, _input().split())
values = [0] * n
links = [[] for _ in range(n)]
for _ in range(n - 1):
a, b = _map(_int, _input().split())
if a >= b:
return
links[a - 1].append(b - 1)
links[b - 1].append(a - 1)
for _ in range(q):
p, x = _map(_int, _input().split())
values[p - 1] += x
d = deque()
d.append((0, -1))
while len(d) != 0:
i, p = d.popleft()
for j in links[i]:
if j == p:
continue
values[j] += values[i]
d.append((j, i))
print((*values))
main()
| false | 7.692308 |
[
"+ if a >= b:",
"+ return"
] | false | 0.045044 | 0.112761 | 0.399466 |
[
"s074339529",
"s461274304"
] |
u540761833
|
p03283
|
python
|
s348194435
|
s758999545
| 1,630 | 1,295 | 51,784 | 73,264 |
Accepted
|
Accepted
| 20.55 |
N,M,Q = list(map(int,input().split()))
num = [[0 for i in range(N)] for j in range(N)]
lr = [list(map(int,input().split())) for i in range(M)]
for l,r in lr:
num[l-1][r-1] += 1
for j in range(N):
for i in range(N-1,0,-1):
num[i-1][j] += num[i][j]
for i in range(N):
for j in range(N-1):
num[i][j+1] += num[i][j]
for i in range(Q):
p,q = list(map(int,input().split()))
print((num[p-1][q-1]))
|
N,M,Q = list(map(int,input().split()))
num = [[0 for i in range(N)] for j in range(N)]
lr = [list(map(int,input().split())) for i in range(M)]
for l,r in lr:
num[l-1][r-1] += 1
for j in range(N):
for i in range(N-1,0,-1):
num[i-1][j] += num[i][j]
for i in range(N):
for j in range(N-1):
num[i][j+1] += num[i][j]
pq = [list(map(int,input().split())) for i in range(Q)]
for p,q in pq:
print((num[p-1][q-1]))
| 15 | 15 | 427 | 445 |
N, M, Q = list(map(int, input().split()))
num = [[0 for i in range(N)] for j in range(N)]
lr = [list(map(int, input().split())) for i in range(M)]
for l, r in lr:
num[l - 1][r - 1] += 1
for j in range(N):
for i in range(N - 1, 0, -1):
num[i - 1][j] += num[i][j]
for i in range(N):
for j in range(N - 1):
num[i][j + 1] += num[i][j]
for i in range(Q):
p, q = list(map(int, input().split()))
print((num[p - 1][q - 1]))
|
N, M, Q = list(map(int, input().split()))
num = [[0 for i in range(N)] for j in range(N)]
lr = [list(map(int, input().split())) for i in range(M)]
for l, r in lr:
num[l - 1][r - 1] += 1
for j in range(N):
for i in range(N - 1, 0, -1):
num[i - 1][j] += num[i][j]
for i in range(N):
for j in range(N - 1):
num[i][j + 1] += num[i][j]
pq = [list(map(int, input().split())) for i in range(Q)]
for p, q in pq:
print((num[p - 1][q - 1]))
| false | 0 |
[
"-for i in range(Q):",
"- p, q = list(map(int, input().split()))",
"+pq = [list(map(int, input().split())) for i in range(Q)]",
"+for p, q in pq:"
] | false | 0.007084 | 0.097226 | 0.072858 |
[
"s348194435",
"s758999545"
] |
u349091349
|
p02696
|
python
|
s804606673
|
s278784123
| 407 | 55 | 79,616 | 61,856 |
Accepted
|
Accepted
| 86.49 |
a,b,n=list(map(int,input().split()))
if n>=b-1:
print((a*(b-1)//b))
else:
print((a*n//b))
|
a, b, n = list(map(int, input().split()))
x = min(b - 1, n)
print((int(a * x / b) - a * int(x / b)))
| 5 | 4 | 87 | 97 |
a, b, n = list(map(int, input().split()))
if n >= b - 1:
print((a * (b - 1) // b))
else:
print((a * n // b))
|
a, b, n = list(map(int, input().split()))
x = min(b - 1, n)
print((int(a * x / b) - a * int(x / b)))
| false | 20 |
[
"-if n >= b - 1:",
"- print((a * (b - 1) // b))",
"-else:",
"- print((a * n // b))",
"+x = min(b - 1, n)",
"+print((int(a * x / b) - a * int(x / b)))"
] | false | 0.055919 | 0.036562 | 1.529411 |
[
"s804606673",
"s278784123"
] |
u620480037
|
p03329
|
python
|
s707214107
|
s617498459
| 615 | 194 | 7,064 | 44,912 |
Accepted
|
Accepted
| 68.46 |
N=int(eval(input()))
A=[]
for i in range(1,10):
if 6**i<=100000:
A.append(6**i)
if 9**i<=100000:
A.append(9**i)
L=[i for i in range(100001)]
A.sort()
for i in range(len(A)):
for j in range(1,100001):
if j>=A[i]:
L[j]=min(L[j],L[j-A[i]]+1)
print((L[N]))
|
N=int(eval(input()))
C=[1]
for i in range(1,100):
if 6**i<=100000:
C.append(6**i)
else:
break
for i in range(1,100):
if 9**i<=100000:
C.append(9**i)
else:
break
dp=[10**6 for i in range(N+1)]
dp[0]=0
for i in C:
for j in range(1,len(dp)):
if j-i>=0:
dp[j]=min(dp[j],dp[j-i]+1)
print((dp[N]))
| 15 | 22 | 307 | 383 |
N = int(eval(input()))
A = []
for i in range(1, 10):
if 6**i <= 100000:
A.append(6**i)
if 9**i <= 100000:
A.append(9**i)
L = [i for i in range(100001)]
A.sort()
for i in range(len(A)):
for j in range(1, 100001):
if j >= A[i]:
L[j] = min(L[j], L[j - A[i]] + 1)
print((L[N]))
|
N = int(eval(input()))
C = [1]
for i in range(1, 100):
if 6**i <= 100000:
C.append(6**i)
else:
break
for i in range(1, 100):
if 9**i <= 100000:
C.append(9**i)
else:
break
dp = [10**6 for i in range(N + 1)]
dp[0] = 0
for i in C:
for j in range(1, len(dp)):
if j - i >= 0:
dp[j] = min(dp[j], dp[j - i] + 1)
print((dp[N]))
| false | 31.818182 |
[
"-A = []",
"-for i in range(1, 10):",
"+C = [1]",
"+for i in range(1, 100):",
"- A.append(6**i)",
"+ C.append(6**i)",
"+ else:",
"+ break",
"+for i in range(1, 100):",
"- A.append(9**i)",
"-L = [i for i in range(100001)]",
"-A.sort()",
"-for i in range(len(A)):",
"- for j in range(1, 100001):",
"- if j >= A[i]:",
"- L[j] = min(L[j], L[j - A[i]] + 1)",
"-print((L[N]))",
"+ C.append(9**i)",
"+ else:",
"+ break",
"+dp = [10**6 for i in range(N + 1)]",
"+dp[0] = 0",
"+for i in C:",
"+ for j in range(1, len(dp)):",
"+ if j - i >= 0:",
"+ dp[j] = min(dp[j], dp[j - i] + 1)",
"+print((dp[N]))"
] | false | 0.785557 | 0.237589 | 3.306365 |
[
"s707214107",
"s617498459"
] |
u330661451
|
p02602
|
python
|
s848894252
|
s467707702
| 127 | 97 | 31,608 | 31,420 |
Accepted
|
Accepted
| 23.62 |
def main():
n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
for i in range(k,n):
print(("Yes" if a[i] > a[i-k] else "No"))
if __name__ == '__main__':
main()
|
def main():
n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
ans = []
for i in range(k,n):
ans.append("Yes" if a[i] > a[i-k] else "No")
print(("\n".join(ans)))
if __name__ == '__main__':
main()
| 9 | 12 | 206 | 254 |
def main():
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
for i in range(k, n):
print(("Yes" if a[i] > a[i - k] else "No"))
if __name__ == "__main__":
main()
|
def main():
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
ans = []
for i in range(k, n):
ans.append("Yes" if a[i] > a[i - k] else "No")
print(("\n".join(ans)))
if __name__ == "__main__":
main()
| false | 25 |
[
"+ ans = []",
"- print((\"Yes\" if a[i] > a[i - k] else \"No\"))",
"+ ans.append(\"Yes\" if a[i] > a[i - k] else \"No\")",
"+ print((\"\\n\".join(ans)))"
] | false | 0.036617 | 0.037812 | 0.968394 |
[
"s848894252",
"s467707702"
] |
u078042885
|
p00184
|
python
|
s007994510
|
s358747197
| 2,460 | 2,170 | 7,600 | 7,504 |
Accepted
|
Accepted
| 11.79 |
# -*- coding: utf-8 -*-
import sys
'import math'
while 1:
n=int(eval(input()))
if n==0: sys.exit()
arr=[0]*7
while n:
a=int(eval(input()))
if a>60: a=61
arr[int(a/10)]+=1
n-=1
for i in range(len(arr)):
print((arr[i]))
|
while 1:
n=int(eval(input()))
if n==0:break
arr=[0]*7
for _ in range(n):
a=int(eval(input()))
if a>60: a=61
arr[a//10]+=1
for i in arr:print(i)
| 14 | 9 | 276 | 183 |
# -*- coding: utf-8 -*-
import sys
"import math"
while 1:
n = int(eval(input()))
if n == 0:
sys.exit()
arr = [0] * 7
while n:
a = int(eval(input()))
if a > 60:
a = 61
arr[int(a / 10)] += 1
n -= 1
for i in range(len(arr)):
print((arr[i]))
|
while 1:
n = int(eval(input()))
if n == 0:
break
arr = [0] * 7
for _ in range(n):
a = int(eval(input()))
if a > 60:
a = 61
arr[a // 10] += 1
for i in arr:
print(i)
| false | 35.714286 |
[
"-# -*- coding: utf-8 -*-",
"-import sys",
"-",
"-\"import math\"",
"- sys.exit()",
"+ break",
"- while n:",
"+ for _ in range(n):",
"- arr[int(a / 10)] += 1",
"- n -= 1",
"- for i in range(len(arr)):",
"- print((arr[i]))",
"+ arr[a // 10] += 1",
"+ for i in arr:",
"+ print(i)"
] | false | 0.041002 | 0.035857 | 1.14348 |
[
"s007994510",
"s358747197"
] |
u790710233
|
p03031
|
python
|
s325501540
|
s155648484
| 36 | 30 | 3,064 | 3,064 |
Accepted
|
Accepted
| 16.67 |
from itertools import product
n, m = list(map(int, input().split()))
ls = []
for _ in range(m):
k, *s, = [int(x)-1 for x in input().split()]
ls.append(s)
p = list(map(int, input().split()))
it = ["01"]*n
ans = 0
for b in product(*it):
base_2 = "".join(b)
for j in range(m):
switchs = ls[j]
cond = p[j]
on_cnt = 0
for switch in switchs:
if int(base_2[switch]):
on_cnt += 1
if on_cnt % 2 != cond:
break
else:
ans += 1
print(ans)
|
n, m = list(map(int, input().split()))
ls = []
for _ in range(m):
k, *s, = [int(x)-1 for x in input().split()]
ls.append(s)
p = list(map(int, input().split()))
ans = 0
def dfs(x, s):
global ans
if x == n:
for j in range(m):
switchs = ls[j]
cond = p[j]
on_cnt = 0
for switch in switchs:
if int(s[switch]):
on_cnt += 1
if on_cnt % 2 != cond:
break
else:
ans += 1
else:
for c in "01":
dfs(x+1, s+c)
dfs(0, "")
print(ans)
| 24 | 30 | 557 | 630 |
from itertools import product
n, m = list(map(int, input().split()))
ls = []
for _ in range(m):
(
k,
*s,
) = [int(x) - 1 for x in input().split()]
ls.append(s)
p = list(map(int, input().split()))
it = ["01"] * n
ans = 0
for b in product(*it):
base_2 = "".join(b)
for j in range(m):
switchs = ls[j]
cond = p[j]
on_cnt = 0
for switch in switchs:
if int(base_2[switch]):
on_cnt += 1
if on_cnt % 2 != cond:
break
else:
ans += 1
print(ans)
|
n, m = list(map(int, input().split()))
ls = []
for _ in range(m):
(
k,
*s,
) = [int(x) - 1 for x in input().split()]
ls.append(s)
p = list(map(int, input().split()))
ans = 0
def dfs(x, s):
global ans
if x == n:
for j in range(m):
switchs = ls[j]
cond = p[j]
on_cnt = 0
for switch in switchs:
if int(s[switch]):
on_cnt += 1
if on_cnt % 2 != cond:
break
else:
ans += 1
else:
for c in "01":
dfs(x + 1, s + c)
dfs(0, "")
print(ans)
| false | 20 |
[
"-from itertools import product",
"-",
"-it = [\"01\"] * n",
"-for b in product(*it):",
"- base_2 = \"\".join(b)",
"- for j in range(m):",
"- switchs = ls[j]",
"- cond = p[j]",
"- on_cnt = 0",
"- for switch in switchs:",
"- if int(base_2[switch]):",
"- on_cnt += 1",
"- if on_cnt % 2 != cond:",
"- break",
"+",
"+",
"+def dfs(x, s):",
"+ global ans",
"+ if x == n:",
"+ for j in range(m):",
"+ switchs = ls[j]",
"+ cond = p[j]",
"+ on_cnt = 0",
"+ for switch in switchs:",
"+ if int(s[switch]):",
"+ on_cnt += 1",
"+ if on_cnt % 2 != cond:",
"+ break",
"+ else:",
"+ ans += 1",
"- ans += 1",
"+ for c in \"01\":",
"+ dfs(x + 1, s + c)",
"+",
"+",
"+dfs(0, \"\")"
] | false | 0.047775 | 0.047267 | 1.010742 |
[
"s325501540",
"s155648484"
] |
u814986259
|
p03854
|
python
|
s668162958
|
s100431335
| 139 | 47 | 3,188 | 3,188 |
Accepted
|
Accepted
| 66.19 |
S = eval(input())
words = ["dream", "dreamer", "erase", "eraser"]
id = len(S)
while(id > 0):
if S[:id].endswith("dream"):
id -= 5
elif S[:id].endswith("dreamer"):
id -= 7
elif S[:id].endswith("erase"):
id -= 5
elif S[:id].endswith("eraser"):
id -= 6
else:
print("NO")
exit(0)
print("YES")
|
S = eval(input())
s = ['dream', 'dreamer', 'erase', 'eraser']
R = len(S)
while(R > 0):
for i in range(4):
if R >= len(s[i]):
if S[R-len(s[i]):R] == s[i]:
R -= len(s[i])
break
if i == 3:
print("NO")
exit(0)
print("YES")
| 17 | 14 | 368 | 315 |
S = eval(input())
words = ["dream", "dreamer", "erase", "eraser"]
id = len(S)
while id > 0:
if S[:id].endswith("dream"):
id -= 5
elif S[:id].endswith("dreamer"):
id -= 7
elif S[:id].endswith("erase"):
id -= 5
elif S[:id].endswith("eraser"):
id -= 6
else:
print("NO")
exit(0)
print("YES")
|
S = eval(input())
s = ["dream", "dreamer", "erase", "eraser"]
R = len(S)
while R > 0:
for i in range(4):
if R >= len(s[i]):
if S[R - len(s[i]) : R] == s[i]:
R -= len(s[i])
break
if i == 3:
print("NO")
exit(0)
print("YES")
| false | 17.647059 |
[
"-words = [\"dream\", \"dreamer\", \"erase\", \"eraser\"]",
"-id = len(S)",
"-while id > 0:",
"- if S[:id].endswith(\"dream\"):",
"- id -= 5",
"- elif S[:id].endswith(\"dreamer\"):",
"- id -= 7",
"- elif S[:id].endswith(\"erase\"):",
"- id -= 5",
"- elif S[:id].endswith(\"eraser\"):",
"- id -= 6",
"- else:",
"- print(\"NO\")",
"- exit(0)",
"+s = [\"dream\", \"dreamer\", \"erase\", \"eraser\"]",
"+R = len(S)",
"+while R > 0:",
"+ for i in range(4):",
"+ if R >= len(s[i]):",
"+ if S[R - len(s[i]) : R] == s[i]:",
"+ R -= len(s[i])",
"+ break",
"+ if i == 3:",
"+ print(\"NO\")",
"+ exit(0)"
] | false | 0.077678 | 0.042671 | 1.820387 |
[
"s668162958",
"s100431335"
] |
u585482323
|
p03013
|
python
|
s749319941
|
s800459192
| 272 | 95 | 61,400 | 24,908 |
Accepted
|
Accepted
| 65.07 |
#!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LS()
return l
sys.setrecursionlimit(1000000)
mod = 1000000007
#A
def A():
p,q,r = LI()
print((p+q+r-max(p,q,r)))
return
#B
def B():
n = I()
w = LI()
ans = float("inf")
for i in range(n):
m = sum(w[:i])
l = sum(w[i:])
ans = min(ans,abs(m-l))
print(ans)
return
#C
def C():
n,m = LI()
f = defaultdict(lambda : 1)
for i in range(m):
a = I()
f[a] = 0
dp = defaultdict(int)
dp[0] = 1
for i in range(1,n+1):
if f[i]:
dp[i] = dp[i-1]+dp[i-2]
dp[i] %= mod
print((dp[n]))
return
#D
def D():
h,w = LI()
s = SR(h)
return
#E
def E():
n = I()
return
#F
def F():
n = I()
return
#Solve
if __name__ == "__main__":
C()
|
#!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LS()
return l
sys.setrecursionlimit(1000000)
mod = 1000000007
#A
def A():
p,q,r = LI()
print((p+q+r-max(p,q,r)))
return
#B
def B():
n = I()
w = LI()
ans = float("inf")
for i in range(n):
m = sum(w[:i])
l = sum(w[i:])
ans = min(ans,abs(m-l))
print(ans)
return
#C
def C():
n,m = LI()
f = defaultdict(lambda : 1)
for i in range(m):
a = I()
f[a] = 0
dp = defaultdict(lambda : 0)
dp[0] = 1
for i in range(1,n+1):
if f[i]:
dp[i] = dp[i-1]+dp[i-2]
dp[i] %= mod
print((dp[n]))
return
#D
def D():
h,w = LI()
s = SR(h)
return
#E
def E():
n = I()
return
#F
def F():
n = I()
return
#Solve
if __name__ == "__main__":
C()
| 87 | 88 | 1,604 | 1,613 |
#!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI():
return list(map(int, sys.stdin.readline().split()))
def I():
return int(sys.stdin.readline())
def LS():
return list(map(list, sys.stdin.readline().split()))
def S():
return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):
l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):
l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):
l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):
l[i] = LS()
return l
sys.setrecursionlimit(1000000)
mod = 1000000007
# A
def A():
p, q, r = LI()
print((p + q + r - max(p, q, r)))
return
# B
def B():
n = I()
w = LI()
ans = float("inf")
for i in range(n):
m = sum(w[:i])
l = sum(w[i:])
ans = min(ans, abs(m - l))
print(ans)
return
# C
def C():
n, m = LI()
f = defaultdict(lambda: 1)
for i in range(m):
a = I()
f[a] = 0
dp = defaultdict(int)
dp[0] = 1
for i in range(1, n + 1):
if f[i]:
dp[i] = dp[i - 1] + dp[i - 2]
dp[i] %= mod
print((dp[n]))
return
# D
def D():
h, w = LI()
s = SR(h)
return
# E
def E():
n = I()
return
# F
def F():
n = I()
return
# Solve
if __name__ == "__main__":
C()
|
#!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI():
return list(map(int, sys.stdin.readline().split()))
def I():
return int(sys.stdin.readline())
def LS():
return list(map(list, sys.stdin.readline().split()))
def S():
return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):
l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):
l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):
l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):
l[i] = LS()
return l
sys.setrecursionlimit(1000000)
mod = 1000000007
# A
def A():
p, q, r = LI()
print((p + q + r - max(p, q, r)))
return
# B
def B():
n = I()
w = LI()
ans = float("inf")
for i in range(n):
m = sum(w[:i])
l = sum(w[i:])
ans = min(ans, abs(m - l))
print(ans)
return
# C
def C():
n, m = LI()
f = defaultdict(lambda: 1)
for i in range(m):
a = I()
f[a] = 0
dp = defaultdict(lambda: 0)
dp[0] = 1
for i in range(1, n + 1):
if f[i]:
dp[i] = dp[i - 1] + dp[i - 2]
dp[i] %= mod
print((dp[n]))
return
# D
def D():
h, w = LI()
s = SR(h)
return
# E
def E():
n = I()
return
# F
def F():
n = I()
return
# Solve
if __name__ == "__main__":
C()
| false | 1.136364 |
[
"- dp = defaultdict(int)",
"+ dp = defaultdict(lambda: 0)"
] | false | 0.088137 | 0.047787 | 1.844353 |
[
"s749319941",
"s800459192"
] |
u597374218
|
p03636
|
python
|
s263218722
|
s893547863
| 19 | 17 | 2,940 | 2,940 |
Accepted
|
Accepted
| 10.53 |
a,*b,c=eval(input())
print((a+str(len(b))+c))
|
s=eval(input())
print((s[0]+str((len(s)-2))+s[-1]))
| 2 | 2 | 38 | 44 |
a, *b, c = eval(input())
print((a + str(len(b)) + c))
|
s = eval(input())
print((s[0] + str((len(s) - 2)) + s[-1]))
| false | 0 |
[
"-a, *b, c = eval(input())",
"-print((a + str(len(b)) + c))",
"+s = eval(input())",
"+print((s[0] + str((len(s) - 2)) + s[-1]))"
] | false | 0.046854 | 0.047127 | 0.994205 |
[
"s263218722",
"s893547863"
] |
u787059958
|
p02791
|
python
|
s786858410
|
s111608203
| 260 | 142 | 75,472 | 25,124 |
Accepted
|
Accepted
| 45.38 |
N = int(eval(input()))
P = list(map(int, input().split()))
count = 1
d = P[0]
for i in range(N - 1):
if (d > P[i + 1]):
d = min(P[i], P[i + 1])
count += 1
print(count)
|
from collections import deque
N = int(eval(input()))
P = list(map(int, input().split()))
d = deque(P)
count = 1
for i in range(1, N):
if (d[0] >= d[1]):
d.popleft()
count += 1
else:
d1 = d.popleft()
d2 = d.popleft()
d.appendleft(d1)
print(count)
| 11 | 17 | 194 | 306 |
N = int(eval(input()))
P = list(map(int, input().split()))
count = 1
d = P[0]
for i in range(N - 1):
if d > P[i + 1]:
d = min(P[i], P[i + 1])
count += 1
print(count)
|
from collections import deque
N = int(eval(input()))
P = list(map(int, input().split()))
d = deque(P)
count = 1
for i in range(1, N):
if d[0] >= d[1]:
d.popleft()
count += 1
else:
d1 = d.popleft()
d2 = d.popleft()
d.appendleft(d1)
print(count)
| false | 35.294118 |
[
"+from collections import deque",
"+",
"+d = deque(P)",
"-d = P[0]",
"-for i in range(N - 1):",
"- if d > P[i + 1]:",
"- d = min(P[i], P[i + 1])",
"+for i in range(1, N):",
"+ if d[0] >= d[1]:",
"+ d.popleft()",
"+ else:",
"+ d1 = d.popleft()",
"+ d2 = d.popleft()",
"+ d.appendleft(d1)"
] | false | 0.036529 | 0.036877 | 0.990549 |
[
"s786858410",
"s111608203"
] |
u394721319
|
p03799
|
python
|
s354769667
|
s128005324
| 176 | 28 | 38,256 | 9,004 |
Accepted
|
Accepted
| 84.09 |
N,M = [int(zz) for zz in input().split()]
ans = 0
if 2*N <= M:
ans += N
M -= 2*N
else:
ans += M//2
M %= 2
ans += M//4
print(ans)
|
N,M = [int(i) for i in input().split()]
ans = min(N,M//2)
if N < M//2:
M -= 2*N
ans += M//4
print(ans)
| 12 | 8 | 158 | 120 |
N, M = [int(zz) for zz in input().split()]
ans = 0
if 2 * N <= M:
ans += N
M -= 2 * N
else:
ans += M // 2
M %= 2
ans += M // 4
print(ans)
|
N, M = [int(i) for i in input().split()]
ans = min(N, M // 2)
if N < M // 2:
M -= 2 * N
ans += M // 4
print(ans)
| false | 33.333333 |
[
"-N, M = [int(zz) for zz in input().split()]",
"-ans = 0",
"-if 2 * N <= M:",
"- ans += N",
"+N, M = [int(i) for i in input().split()]",
"+ans = min(N, M // 2)",
"+if N < M // 2:",
"-else:",
"- ans += M // 2",
"- M %= 2",
"-ans += M // 4",
"+ ans += M // 4"
] | false | 0.040882 | 0.036223 | 1.128617 |
[
"s354769667",
"s128005324"
] |
u089142196
|
p02948
|
python
|
s641257804
|
s243741324
| 631 | 435 | 26,896 | 29,996 |
Accepted
|
Accepted
| 31.06 |
from heapq import heapify, heappop, heappush
from collections import deque
N,M=list(map(int,input().split()))
A=[0]*N #ラグ
B=[0]*N #報酬
C=[0]*N
for i in range(N):
A[i],B[i]= list(map(int,input().split()))
C[i]=[A[i],B[i]]
C.sort()
D=deque(C)
reward=0
#print(D)
h=[]
heapify(h)
for i in range(M-1,-1,-1):
while D:
e = D.popleft()
if e[0]==M-i:
heappush(h,-1*e[1])
else:
D.appendleft(e)
break
#print(h)
if h:
reward += (-1)*heappop(h)
print(reward)
|
from heapq import heappop,heappush,heapify
from collections import deque
N,M=list(map(int,input().split()))
A,B,C = [0]*N,[0]*N,[0]*N
for i in range(N):
A[i],B[i] = list(map(int,input().split()))
C[i]=[A[i],B[i]]
C.sort()
C=deque(C)
a=[]
heapify(a)
ans=0
for i in range(M,-1,-1):
while C:
if C[0][0]<=M-i:
heappush(a,(-1)*C[0][1])
C.popleft()
else:
break
if len(a)>0:
p = heappop(a)
ans += (-1)*p
print(ans)
| 30 | 27 | 564 | 517 |
from heapq import heapify, heappop, heappush
from collections import deque
N, M = list(map(int, input().split()))
A = [0] * N # ラグ
B = [0] * N # 報酬
C = [0] * N
for i in range(N):
A[i], B[i] = list(map(int, input().split()))
C[i] = [A[i], B[i]]
C.sort()
D = deque(C)
reward = 0
# print(D)
h = []
heapify(h)
for i in range(M - 1, -1, -1):
while D:
e = D.popleft()
if e[0] == M - i:
heappush(h, -1 * e[1])
else:
D.appendleft(e)
break
# print(h)
if h:
reward += (-1) * heappop(h)
print(reward)
|
from heapq import heappop, heappush, heapify
from collections import deque
N, M = list(map(int, input().split()))
A, B, C = [0] * N, [0] * N, [0] * N
for i in range(N):
A[i], B[i] = list(map(int, input().split()))
C[i] = [A[i], B[i]]
C.sort()
C = deque(C)
a = []
heapify(a)
ans = 0
for i in range(M, -1, -1):
while C:
if C[0][0] <= M - i:
heappush(a, (-1) * C[0][1])
C.popleft()
else:
break
if len(a) > 0:
p = heappop(a)
ans += (-1) * p
print(ans)
| false | 10 |
[
"-from heapq import heapify, heappop, heappush",
"+from heapq import heappop, heappush, heapify",
"-A = [0] * N # ラグ",
"-B = [0] * N # 報酬",
"-C = [0] * N",
"+A, B, C = [0] * N, [0] * N, [0] * N",
"-D = deque(C)",
"-reward = 0",
"-# print(D)",
"-h = []",
"-heapify(h)",
"-for i in range(M - 1, -1, -1):",
"- while D:",
"- e = D.popleft()",
"- if e[0] == M - i:",
"- heappush(h, -1 * e[1])",
"+C = deque(C)",
"+a = []",
"+heapify(a)",
"+ans = 0",
"+for i in range(M, -1, -1):",
"+ while C:",
"+ if C[0][0] <= M - i:",
"+ heappush(a, (-1) * C[0][1])",
"+ C.popleft()",
"- D.appendleft(e)",
"- # print(h)",
"- if h:",
"- reward += (-1) * heappop(h)",
"-print(reward)",
"+ if len(a) > 0:",
"+ p = heappop(a)",
"+ ans += (-1) * p",
"+print(ans)"
] | false | 0.08879 | 0.130662 | 0.679544 |
[
"s641257804",
"s243741324"
] |
u312025627
|
p02722
|
python
|
s135289232
|
s028720357
| 205 | 84 | 39,920 | 65,012 |
Accepted
|
Accepted
| 59.02 |
def main():
def trial_division(n):
divs = set()
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divs.add(i)
if i != n//i:
divs.add(n//i)
return divs
def gcd(x, y):
if y == 0:
return x
while y != 0:
x, y = y, x % y
return x
N = int(eval(input()))
ans = 0
divs = trial_division(N) | trial_division(N-1)
for d in divs:
if d == 1:
continue
num = N
while num % d == 0 and d <= num:
num //= d
if num % d == 1:
ans += 1
print(ans)
if __name__ == '__main__':
main()
|
def main():
N = int(eval(input()))
def enum_divisors(n):
# 約数列挙
divs = []
for i in range(1, n+1):
if i*i > n:
break
if n % i == 0:
divs.append(i)
if n//i != i:
# i が平方数でない
divs.append(n//i)
return divs
ans = 0
for k in enum_divisors(N-1):
if 2 <= k:
ans += 1
for k in enum_divisors(N):
if 2 <= k:
n = N
while n > 1 and n % k == 0:
n //= k
if n % k == 1:
ans += 1
print(ans)
if __name__ == '__main__':
main()
| 34 | 34 | 727 | 709 |
def main():
def trial_division(n):
divs = set()
for i in range(1, int(n**0.5) + 1):
if n % i == 0:
divs.add(i)
if i != n // i:
divs.add(n // i)
return divs
def gcd(x, y):
if y == 0:
return x
while y != 0:
x, y = y, x % y
return x
N = int(eval(input()))
ans = 0
divs = trial_division(N) | trial_division(N - 1)
for d in divs:
if d == 1:
continue
num = N
while num % d == 0 and d <= num:
num //= d
if num % d == 1:
ans += 1
print(ans)
if __name__ == "__main__":
main()
|
def main():
N = int(eval(input()))
def enum_divisors(n):
# 約数列挙
divs = []
for i in range(1, n + 1):
if i * i > n:
break
if n % i == 0:
divs.append(i)
if n // i != i:
# i が平方数でない
divs.append(n // i)
return divs
ans = 0
for k in enum_divisors(N - 1):
if 2 <= k:
ans += 1
for k in enum_divisors(N):
if 2 <= k:
n = N
while n > 1 and n % k == 0:
n //= k
if n % k == 1:
ans += 1
print(ans)
if __name__ == "__main__":
main()
| false | 0 |
[
"- def trial_division(n):",
"- divs = set()",
"- for i in range(1, int(n**0.5) + 1):",
"+ N = int(eval(input()))",
"+",
"+ def enum_divisors(n):",
"+ # 約数列挙",
"+ divs = []",
"+ for i in range(1, n + 1):",
"+ if i * i > n:",
"+ break",
"- divs.add(i)",
"- if i != n // i:",
"- divs.add(n // i)",
"+ divs.append(i)",
"+ if n // i != i:",
"+ # i が平方数でない",
"+ divs.append(n // i)",
"- def gcd(x, y):",
"- if y == 0:",
"- return x",
"- while y != 0:",
"- x, y = y, x % y",
"- return x",
"-",
"- N = int(eval(input()))",
"- divs = trial_division(N) | trial_division(N - 1)",
"- for d in divs:",
"- if d == 1:",
"- continue",
"- num = N",
"- while num % d == 0 and d <= num:",
"- num //= d",
"- if num % d == 1:",
"+ for k in enum_divisors(N - 1):",
"+ if 2 <= k:",
"+ for k in enum_divisors(N):",
"+ if 2 <= k:",
"+ n = N",
"+ while n > 1 and n % k == 0:",
"+ n //= k",
"+ if n % k == 1:",
"+ ans += 1"
] | false | 0.065148 | 0.157003 | 0.414949 |
[
"s135289232",
"s028720357"
] |
u156815136
|
p02779
|
python
|
s115120094
|
s772538959
| 196 | 107 | 32,972 | 33,024 |
Accepted
|
Accepted
| 45.41 |
#from statistics import median
#import collections
#aa = collections.Counter(a) # list to list
#from itertools import combinations # (string,3) 3回
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#
mod = 10**9 + 7
def readInts():
return list(map(int,input().split()))
def main():
n = int(eval(input()))
A = sorted(readInts())
dic = {}
for a in A:
if a in dic:
print('NO')
exit()
else:
dic[a] = 1
print('YES')
if __name__ == '__main__':
main()
|
#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()))
n = I()
A = list(set(readInts()))
print(('YES' if n == len(A) else 'NO'))
| 27 | 32 | 531 | 797 |
# from statistics import median
# import collections
# aa = collections.Counter(a) # list to list
# from itertools import combinations # (string,3) 3回
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#
mod = 10**9 + 7
def readInts():
return list(map(int, input().split()))
def main():
n = int(eval(input()))
A = sorted(readInts())
dic = {}
for a in A:
if a in dic:
print("NO")
exit()
else:
dic[a] = 1
print("YES")
if __name__ == "__main__":
main()
|
# 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()))
n = I()
A = list(set(readInts()))
print(("YES" if n == len(A) else "NO"))
| false | 15.625 |
[
"-# aa = collections.Counter(a) # list to list",
"-# from itertools import combinations # (string,3) 3回",
"+# 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:",
"+#",
"+# my_round_int = lambda x:np.round((x*2 + 1)//2)",
"+# 四捨五入",
"+import sys",
"+",
"+sys.setrecursionlimit(10000000)",
"-",
"-",
"+# mod = 9982443453",
"-def main():",
"- n = int(eval(input()))",
"- A = sorted(readInts())",
"- dic = {}",
"- for a in A:",
"- if a in dic:",
"- print(\"NO\")",
"- exit()",
"- else:",
"- dic[a] = 1",
"- print(\"YES\")",
"+def I():",
"+ return int(eval(input()))",
"-if __name__ == \"__main__\":",
"- main()",
"+n = I()",
"+A = list(set(readInts()))",
"+print((\"YES\" if n == len(A) else \"NO\"))"
] | false | 0.065209 | 0.063205 | 1.031702 |
[
"s115120094",
"s772538959"
] |
u235210692
|
p02924
|
python
|
s499424776
|
s020784861
| 180 | 18 | 38,384 | 2,940 |
Accepted
|
Accepted
| 90 |
n=int(eval(input()))
print((n*(n-1)//2))
|
n=int(eval(input()))
print(((n*(n-1))//2))
| 2 | 3 | 33 | 37 |
n = int(eval(input()))
print((n * (n - 1) // 2))
|
n = int(eval(input()))
print(((n * (n - 1)) // 2))
| false | 33.333333 |
[
"-print((n * (n - 1) // 2))",
"+print(((n * (n - 1)) // 2))"
] | false | 0.109086 | 0.035862 | 3.041871 |
[
"s499424776",
"s020784861"
] |
u126232616
|
p02954
|
python
|
s683006387
|
s286068409
| 129 | 118 | 6,528 | 6,400 |
Accepted
|
Accepted
| 8.53 |
S = eval(input())
n = len(S)
ans = [0 for i in range(n)]
r_st,r_en,l_st,l_en = 0,0,0,0
for i in range(1,n):
if S[i] == "R":
if S[i-1] == "L": #L➡R
l_en = i-1
rnum = r_en-r_st+1
lnum = l_en-l_st+1
if (rnum+lnum)%2 == 0:
ans[r_en],ans[l_st] = (rnum+lnum)//2,(rnum+lnum)//2
else:
evnum = (rnum + lnum + 1) // 2
odnum = evnum - 1
if rnum%2 == 0:
ans[r_en] = odnum
ans[l_st] = evnum
else:
ans[r_en] = evnum
ans[l_st] = odnum
r_st = i
else:
if S[i-1] == "R": #R➡L
r_en = i-1
l_st = i
if i == n-1:
l_en = i
rnum = r_en-r_st+1
lnum = l_en-l_st+1
#print(rnum, lnum)
if (rnum+lnum)%2 == 0:
ans[r_en],ans[l_st] = (rnum+lnum)//2,(rnum+lnum)//2
else:
evnum = (rnum + lnum + 1) // 2
odnum = evnum - 1
if rnum%2 == 0:
ans[r_en] = odnum
ans[l_st] = evnum
else:
ans[r_en] = evnum
ans[l_st] = odnum
r_st = i
print((*ans))
|
s = eval(input())
n = len(s)
ans = [0]*n
s += "R"
lastl = -1
lastr = 0
for i in range(n):
if s[i] == "R" and s[i+1] == "L":
lastr = i
if s[i] == "L" and s[i+1] == "R":
su = i-lastl
if su%2 == 0:
ans[lastr],ans[lastr+1] = su//2,su//2
else:
#print((su+1)//2,(su-1)//2)
ans[lastr],ans[lastr+1] = ((su+1)//2,(su-1)//2) if (lastr-lastl)%2!=0 else ((su-1)//2,(su+1)//2)
lastl = i
print((*ans))
| 45 | 18 | 1,372 | 481 |
S = eval(input())
n = len(S)
ans = [0 for i in range(n)]
r_st, r_en, l_st, l_en = 0, 0, 0, 0
for i in range(1, n):
if S[i] == "R":
if S[i - 1] == "L": # L➡R
l_en = i - 1
rnum = r_en - r_st + 1
lnum = l_en - l_st + 1
if (rnum + lnum) % 2 == 0:
ans[r_en], ans[l_st] = (rnum + lnum) // 2, (rnum + lnum) // 2
else:
evnum = (rnum + lnum + 1) // 2
odnum = evnum - 1
if rnum % 2 == 0:
ans[r_en] = odnum
ans[l_st] = evnum
else:
ans[r_en] = evnum
ans[l_st] = odnum
r_st = i
else:
if S[i - 1] == "R": # R➡L
r_en = i - 1
l_st = i
if i == n - 1:
l_en = i
rnum = r_en - r_st + 1
lnum = l_en - l_st + 1
# print(rnum, lnum)
if (rnum + lnum) % 2 == 0:
ans[r_en], ans[l_st] = (rnum + lnum) // 2, (rnum + lnum) // 2
else:
evnum = (rnum + lnum + 1) // 2
odnum = evnum - 1
if rnum % 2 == 0:
ans[r_en] = odnum
ans[l_st] = evnum
else:
ans[r_en] = evnum
ans[l_st] = odnum
r_st = i
print((*ans))
|
s = eval(input())
n = len(s)
ans = [0] * n
s += "R"
lastl = -1
lastr = 0
for i in range(n):
if s[i] == "R" and s[i + 1] == "L":
lastr = i
if s[i] == "L" and s[i + 1] == "R":
su = i - lastl
if su % 2 == 0:
ans[lastr], ans[lastr + 1] = su // 2, su // 2
else:
# print((su+1)//2,(su-1)//2)
ans[lastr], ans[lastr + 1] = (
((su + 1) // 2, (su - 1) // 2)
if (lastr - lastl) % 2 != 0
else ((su - 1) // 2, (su + 1) // 2)
)
lastl = i
print((*ans))
| false | 60 |
[
"-S = eval(input())",
"-n = len(S)",
"-ans = [0 for i in range(n)]",
"-r_st, r_en, l_st, l_en = 0, 0, 0, 0",
"-for i in range(1, n):",
"- if S[i] == \"R\":",
"- if S[i - 1] == \"L\": # L➡R",
"- l_en = i - 1",
"- rnum = r_en - r_st + 1",
"- lnum = l_en - l_st + 1",
"- if (rnum + lnum) % 2 == 0:",
"- ans[r_en], ans[l_st] = (rnum + lnum) // 2, (rnum + lnum) // 2",
"- else:",
"- evnum = (rnum + lnum + 1) // 2",
"- odnum = evnum - 1",
"- if rnum % 2 == 0:",
"- ans[r_en] = odnum",
"- ans[l_st] = evnum",
"- else:",
"- ans[r_en] = evnum",
"- ans[l_st] = odnum",
"- r_st = i",
"- else:",
"- if S[i - 1] == \"R\": # R➡L",
"- r_en = i - 1",
"- l_st = i",
"- if i == n - 1:",
"- l_en = i",
"- rnum = r_en - r_st + 1",
"- lnum = l_en - l_st + 1",
"- # print(rnum, lnum)",
"- if (rnum + lnum) % 2 == 0:",
"- ans[r_en], ans[l_st] = (rnum + lnum) // 2, (rnum + lnum) // 2",
"- else:",
"- evnum = (rnum + lnum + 1) // 2",
"- odnum = evnum - 1",
"- if rnum % 2 == 0:",
"- ans[r_en] = odnum",
"- ans[l_st] = evnum",
"- else:",
"- ans[r_en] = evnum",
"- ans[l_st] = odnum",
"- r_st = i",
"+s = eval(input())",
"+n = len(s)",
"+ans = [0] * n",
"+s += \"R\"",
"+lastl = -1",
"+lastr = 0",
"+for i in range(n):",
"+ if s[i] == \"R\" and s[i + 1] == \"L\":",
"+ lastr = i",
"+ if s[i] == \"L\" and s[i + 1] == \"R\":",
"+ su = i - lastl",
"+ if su % 2 == 0:",
"+ ans[lastr], ans[lastr + 1] = su // 2, su // 2",
"+ else:",
"+ # print((su+1)//2,(su-1)//2)",
"+ ans[lastr], ans[lastr + 1] = (",
"+ ((su + 1) // 2, (su - 1) // 2)",
"+ if (lastr - lastl) % 2 != 0",
"+ else ((su - 1) // 2, (su + 1) // 2)",
"+ )",
"+ lastl = i"
] | false | 0.051098 | 0.036013 | 1.418896 |
[
"s683006387",
"s286068409"
] |
u055941944
|
p04012
|
python
|
s758737111
|
s489709534
| 21 | 17 | 3,316 | 3,060 |
Accepted
|
Accepted
| 19.05 |
from collections import Counter
w=list(str(eval(input())))
h=set(w)
for i in h:
if w.count(i)%2!=0:
print("No")
exit()
print("Yes")
|
w=str(eval(input()))
x=["a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"]
z=[]
for i in range(len(x)):
if w.count(x[i])%2!=0:
z.append(11)
else:
z.append(3)
if 11 in z:
print("No")
else:
print("Yes")
| 11 | 13 | 159 | 294 |
from collections import Counter
w = list(str(eval(input())))
h = set(w)
for i in h:
if w.count(i) % 2 != 0:
print("No")
exit()
print("Yes")
|
w = str(eval(input()))
x = [
"a",
"b",
"c",
"d",
"e",
"f",
"g",
"h",
"i",
"j",
"k",
"l",
"m",
"n",
"o",
"p",
"q",
"r",
"s",
"t",
"u",
"v",
"w",
"x",
"y",
"z",
]
z = []
for i in range(len(x)):
if w.count(x[i]) % 2 != 0:
z.append(11)
else:
z.append(3)
if 11 in z:
print("No")
else:
print("Yes")
| false | 15.384615 |
[
"-from collections import Counter",
"-",
"-w = list(str(eval(input())))",
"-h = set(w)",
"-for i in h:",
"- if w.count(i) % 2 != 0:",
"- print(\"No\")",
"- exit()",
"-print(\"Yes\")",
"+w = str(eval(input()))",
"+x = [",
"+ \"a\",",
"+ \"b\",",
"+ \"c\",",
"+ \"d\",",
"+ \"e\",",
"+ \"f\",",
"+ \"g\",",
"+ \"h\",",
"+ \"i\",",
"+ \"j\",",
"+ \"k\",",
"+ \"l\",",
"+ \"m\",",
"+ \"n\",",
"+ \"o\",",
"+ \"p\",",
"+ \"q\",",
"+ \"r\",",
"+ \"s\",",
"+ \"t\",",
"+ \"u\",",
"+ \"v\",",
"+ \"w\",",
"+ \"x\",",
"+ \"y\",",
"+ \"z\",",
"+]",
"+z = []",
"+for i in range(len(x)):",
"+ if w.count(x[i]) % 2 != 0:",
"+ z.append(11)",
"+ else:",
"+ z.append(3)",
"+if 11 in z:",
"+ print(\"No\")",
"+else:",
"+ print(\"Yes\")"
] | false | 0.039828 | 0.085795 | 0.464225 |
[
"s758737111",
"s489709534"
] |
u968166680
|
p03014
|
python
|
s390211007
|
s611043766
| 1,632 | 765 | 385,536 | 122,076 |
Accepted
|
Accepted
| 53.12 |
import sys
from itertools import groupby
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
def len_count(S):
H, W = len(S), len(S[0])
L = [[0] * W for _ in range(H)]
for row_S, row_L in zip(S, L):
vec = [1]
for i in range(1, W):
if row_S[i - 1] == row_S[i]:
vec[-1] += 1
else:
vec.append(1)
idx = 0
valid = row_S[0] == '.'
for n in vec:
if valid:
for i in range(idx, idx + n):
row_L[i] = n
idx += n
valid = not valid
return L
def main():
H, W = list(map(int, readline().split()))
S = [readline().strip() for _ in range(H)]
L1 = len_count(S)
L2 = len_count(list(zip(*S)))
ans = 0
for i in range(H):
for j in range(W):
if ans < L1[i][j] + L2[j][i] - 1:
ans = L1[i][j] + L2[j][i] - 1
print(ans)
return
if __name__ == '__main__':
main()
|
import sys
from itertools import groupby
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
def len_count(S):
H, W = len(S), len(S[0])
L = [[0] * W for _ in range(H)]
for row_S, row_L in zip(S, L):
vec = [1]
for i in range(1, W):
if row_S[i - 1] == row_S[i]:
vec[-1] += 1
else:
vec.append(1)
idx = 0
valid = row_S[0] == '.'
for n in vec:
if valid:
for i in range(idx, idx + n):
row_L[i] = n
idx += n
valid = not valid
return L
def main():
H, W = list(map(int, readline().split()))
S = [readline().strip() for _ in range(H)]
L1 = [[0] * W for _ in range(H)]
for x in range(H):
vec = [1]
for i in range(1, W):
if S[x][i - 1] == S[x][i]:
vec[-1] += 1
else:
vec.append(1)
idx = 0
valid = S[x][0] == '.'
for n in vec:
if valid:
for i in range(idx, idx + n):
L1[x][i] = n
idx += n
valid = not valid
L2 = [[0] * W for _ in range(H)]
for y in range(W):
vec = [1]
for i in range(1, H):
if S[i - 1][y] == S[i][y]:
vec[-1] += 1
else:
vec.append(1)
idx = 0
valid = S[0][y] == '.'
for n in vec:
if valid:
for i in range(idx, idx + n):
L2[i][y] = n
idx += n
valid = not valid
ans = 0
for i in range(H):
for j in range(W):
if ans < L1[i][j] + L2[i][j] - 1:
ans = L1[i][j] + L2[i][j] - 1
print(ans)
return
if __name__ == '__main__':
main()
| 52 | 85 | 1,125 | 1,995 |
import sys
from itertools import groupby
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10**9)
INF = 1 << 60
def len_count(S):
H, W = len(S), len(S[0])
L = [[0] * W for _ in range(H)]
for row_S, row_L in zip(S, L):
vec = [1]
for i in range(1, W):
if row_S[i - 1] == row_S[i]:
vec[-1] += 1
else:
vec.append(1)
idx = 0
valid = row_S[0] == "."
for n in vec:
if valid:
for i in range(idx, idx + n):
row_L[i] = n
idx += n
valid = not valid
return L
def main():
H, W = list(map(int, readline().split()))
S = [readline().strip() for _ in range(H)]
L1 = len_count(S)
L2 = len_count(list(zip(*S)))
ans = 0
for i in range(H):
for j in range(W):
if ans < L1[i][j] + L2[j][i] - 1:
ans = L1[i][j] + L2[j][i] - 1
print(ans)
return
if __name__ == "__main__":
main()
|
import sys
from itertools import groupby
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10**9)
INF = 1 << 60
def len_count(S):
H, W = len(S), len(S[0])
L = [[0] * W for _ in range(H)]
for row_S, row_L in zip(S, L):
vec = [1]
for i in range(1, W):
if row_S[i - 1] == row_S[i]:
vec[-1] += 1
else:
vec.append(1)
idx = 0
valid = row_S[0] == "."
for n in vec:
if valid:
for i in range(idx, idx + n):
row_L[i] = n
idx += n
valid = not valid
return L
def main():
H, W = list(map(int, readline().split()))
S = [readline().strip() for _ in range(H)]
L1 = [[0] * W for _ in range(H)]
for x in range(H):
vec = [1]
for i in range(1, W):
if S[x][i - 1] == S[x][i]:
vec[-1] += 1
else:
vec.append(1)
idx = 0
valid = S[x][0] == "."
for n in vec:
if valid:
for i in range(idx, idx + n):
L1[x][i] = n
idx += n
valid = not valid
L2 = [[0] * W for _ in range(H)]
for y in range(W):
vec = [1]
for i in range(1, H):
if S[i - 1][y] == S[i][y]:
vec[-1] += 1
else:
vec.append(1)
idx = 0
valid = S[0][y] == "."
for n in vec:
if valid:
for i in range(idx, idx + n):
L2[i][y] = n
idx += n
valid = not valid
ans = 0
for i in range(H):
for j in range(W):
if ans < L1[i][j] + L2[i][j] - 1:
ans = L1[i][j] + L2[i][j] - 1
print(ans)
return
if __name__ == "__main__":
main()
| false | 38.823529 |
[
"- L1 = len_count(S)",
"- L2 = len_count(list(zip(*S)))",
"+ L1 = [[0] * W for _ in range(H)]",
"+ for x in range(H):",
"+ vec = [1]",
"+ for i in range(1, W):",
"+ if S[x][i - 1] == S[x][i]:",
"+ vec[-1] += 1",
"+ else:",
"+ vec.append(1)",
"+ idx = 0",
"+ valid = S[x][0] == \".\"",
"+ for n in vec:",
"+ if valid:",
"+ for i in range(idx, idx + n):",
"+ L1[x][i] = n",
"+ idx += n",
"+ valid = not valid",
"+ L2 = [[0] * W for _ in range(H)]",
"+ for y in range(W):",
"+ vec = [1]",
"+ for i in range(1, H):",
"+ if S[i - 1][y] == S[i][y]:",
"+ vec[-1] += 1",
"+ else:",
"+ vec.append(1)",
"+ idx = 0",
"+ valid = S[0][y] == \".\"",
"+ for n in vec:",
"+ if valid:",
"+ for i in range(idx, idx + n):",
"+ L2[i][y] = n",
"+ idx += n",
"+ valid = not valid",
"- if ans < L1[i][j] + L2[j][i] - 1:",
"- ans = L1[i][j] + L2[j][i] - 1",
"+ if ans < L1[i][j] + L2[i][j] - 1:",
"+ ans = L1[i][j] + L2[i][j] - 1"
] | false | 0.048142 | 0.049264 | 0.977242 |
[
"s390211007",
"s611043766"
] |
u562935282
|
p03260
|
python
|
s263453839
|
s837253900
| 20 | 17 | 3,316 | 2,940 |
Accepted
|
Accepted
| 15 |
def iin(): return int(eval(input()))
def nl(): return list(map(int, input().split()))
a, b = nl()
print(('No' if a * b % 2 == 0 else 'Yes'))
|
a, b = list(map(int, input().split()))
print(('Yes' if a * b % 2 == 1 else 'No'))
| 5 | 2 | 137 | 74 |
def iin():
return int(eval(input()))
def nl():
return list(map(int, input().split()))
a, b = nl()
print(("No" if a * b % 2 == 0 else "Yes"))
|
a, b = list(map(int, input().split()))
print(("Yes" if a * b % 2 == 1 else "No"))
| false | 60 |
[
"-def iin():",
"- return int(eval(input()))",
"-",
"-",
"-def nl():",
"- return list(map(int, input().split()))",
"-",
"-",
"-a, b = nl()",
"-print((\"No\" if a * b % 2 == 0 else \"Yes\"))",
"+a, b = list(map(int, input().split()))",
"+print((\"Yes\" if a * b % 2 == 1 else \"No\"))"
] | false | 0.050258 | 0.050533 | 0.994545 |
[
"s263453839",
"s837253900"
] |
u624475441
|
p03714
|
python
|
s654731732
|
s275911229
| 353 | 271 | 36,308 | 36,308 |
Accepted
|
Accepted
| 23.23 |
from heapq import heapify, heappushpop
N, *a = list(map(int, open(0).read().split()))
hq1 = a[:N]
hq2 = [-ai for ai in a[-N:]]
heapify(hq1)
heapify(hq2)
sum1 = [sum(hq1)]
sum2 = [sum(hq2)]
for k in range(N, 2 * N):
sum1.append(sum1[-1] + a[k] - heappushpop(hq1, a[k]))
sum2.append(sum2[-1] - a[-k - 1] - heappushpop(hq2, -a[-k - 1]))
print((max(list(map(sum, list(zip(sum1, sum2[::-1])))))))
|
from heapq import heapify, heappushpop
N, *A = list(map(int, open(0).read().split()))
def f(L):
q = L[:N]
heapify(q)
s = sum(q)
yield s
for e in L[N:2 * N]:
s += e - heappushpop(q, e)
yield s
print((max(list(map(sum, list(zip(f(A), list(f([-a for a in A[::-1]]))[::-1])))))))
| 16 | 11 | 398 | 301 |
from heapq import heapify, heappushpop
N, *a = list(map(int, open(0).read().split()))
hq1 = a[:N]
hq2 = [-ai for ai in a[-N:]]
heapify(hq1)
heapify(hq2)
sum1 = [sum(hq1)]
sum2 = [sum(hq2)]
for k in range(N, 2 * N):
sum1.append(sum1[-1] + a[k] - heappushpop(hq1, a[k]))
sum2.append(sum2[-1] - a[-k - 1] - heappushpop(hq2, -a[-k - 1]))
print((max(list(map(sum, list(zip(sum1, sum2[::-1])))))))
|
from heapq import heapify, heappushpop
N, *A = list(map(int, open(0).read().split()))
def f(L):
q = L[:N]
heapify(q)
s = sum(q)
yield s
for e in L[N : 2 * N]:
s += e - heappushpop(q, e)
yield s
print((max(list(map(sum, list(zip(f(A), list(f([-a for a in A[::-1]]))[::-1])))))))
| false | 31.25 |
[
"-N, *a = list(map(int, open(0).read().split()))",
"-hq1 = a[:N]",
"-hq2 = [-ai for ai in a[-N:]]",
"-heapify(hq1)",
"-heapify(hq2)",
"-sum1 = [sum(hq1)]",
"-sum2 = [sum(hq2)]",
"-for k in range(N, 2 * N):",
"- sum1.append(sum1[-1] + a[k] - heappushpop(hq1, a[k]))",
"- sum2.append(sum2[-1] - a[-k - 1] - heappushpop(hq2, -a[-k - 1]))",
"-print((max(list(map(sum, list(zip(sum1, sum2[::-1])))))))",
"+N, *A = list(map(int, open(0).read().split()))",
"+",
"+",
"+def f(L):",
"+ q = L[:N]",
"+ heapify(q)",
"+ s = sum(q)",
"+ yield s",
"+ for e in L[N : 2 * N]:",
"+ s += e - heappushpop(q, e)",
"+ yield s",
"+",
"+",
"+print((max(list(map(sum, list(zip(f(A), list(f([-a for a in A[::-1]]))[::-1])))))))"
] | false | 0.038673 | 0.037724 | 1.025176 |
[
"s654731732",
"s275911229"
] |
u281303342
|
p03761
|
python
|
s622152101
|
s394706018
| 22 | 19 | 3,316 | 3,060 |
Accepted
|
Accepted
| 13.64 |
from collections import Counter
N = int(eval(input()))
D = {chr(x+97):100 for x in range(26)}
for i in range(N):
C = Counter(eval(input()))
for j in range(26):
x = chr(j+97)
D[x] = min(D[x],C[x])
Ans = ""
for i in range(26):
x = chr(i+97)
Ans += x*D[x]
print(Ans)
|
N = int(eval(input()))
S = []
for i in range(N):
s = eval(input())
S.append(s)
ans = []
chars = "abcdefghijklmnopqrstuvwxyz"
for c in chars:
cnt = 999
for i in range(N):
cnt = min(cnt, S[i].count(c))
for i in range(cnt):
ans.append(c)
print(("".join(ans)))
| 13 | 16 | 295 | 296 |
from collections import Counter
N = int(eval(input()))
D = {chr(x + 97): 100 for x in range(26)}
for i in range(N):
C = Counter(eval(input()))
for j in range(26):
x = chr(j + 97)
D[x] = min(D[x], C[x])
Ans = ""
for i in range(26):
x = chr(i + 97)
Ans += x * D[x]
print(Ans)
|
N = int(eval(input()))
S = []
for i in range(N):
s = eval(input())
S.append(s)
ans = []
chars = "abcdefghijklmnopqrstuvwxyz"
for c in chars:
cnt = 999
for i in range(N):
cnt = min(cnt, S[i].count(c))
for i in range(cnt):
ans.append(c)
print(("".join(ans)))
| false | 18.75 |
[
"-from collections import Counter",
"-",
"-D = {chr(x + 97): 100 for x in range(26)}",
"+S = []",
"- C = Counter(eval(input()))",
"- for j in range(26):",
"- x = chr(j + 97)",
"- D[x] = min(D[x], C[x])",
"-Ans = \"\"",
"-for i in range(26):",
"- x = chr(i + 97)",
"- Ans += x * D[x]",
"-print(Ans)",
"+ s = eval(input())",
"+ S.append(s)",
"+ans = []",
"+chars = \"abcdefghijklmnopqrstuvwxyz\"",
"+for c in chars:",
"+ cnt = 999",
"+ for i in range(N):",
"+ cnt = min(cnt, S[i].count(c))",
"+ for i in range(cnt):",
"+ ans.append(c)",
"+print((\"\".join(ans)))"
] | false | 0.120014 | 0.042919 | 2.796282 |
[
"s622152101",
"s394706018"
] |
u546285759
|
p00314
|
python
|
s028605385
|
s948462898
| 40 | 30 | 7,732 | 7,708 |
Accepted
|
Accepted
| 25 |
N = int(eval(input()))
p = list(map(int, input().split()))
score = [0] * 101
for x in p:
score[x] += 1
i = 1
while sum(score[i:]) >= i:
i += 1
print((i-1))
|
N = int(eval(input()))
p = list(map(int, input().split()))
score = [0] * 101
for x in p:
score[x] += 1
i = 1
while True:
if sum(score[i:]) < i:
break
i += 1
print((i-1))
| 10 | 12 | 169 | 193 |
N = int(eval(input()))
p = list(map(int, input().split()))
score = [0] * 101
for x in p:
score[x] += 1
i = 1
while sum(score[i:]) >= i:
i += 1
print((i - 1))
|
N = int(eval(input()))
p = list(map(int, input().split()))
score = [0] * 101
for x in p:
score[x] += 1
i = 1
while True:
if sum(score[i:]) < i:
break
i += 1
print((i - 1))
| false | 16.666667 |
[
"-while sum(score[i:]) >= i:",
"+while True:",
"+ if sum(score[i:]) < i:",
"+ break"
] | false | 0.192379 | 0.130531 | 1.47382 |
[
"s028605385",
"s948462898"
] |
u983918956
|
p03722
|
python
|
s956509180
|
s648846903
| 1,661 | 947 | 3,364 | 3,308 |
Accepted
|
Accepted
| 42.99 |
inf = float('inf')
N, M = list(map(int,input().split()))
edges = []
for _ in range(M):
a, b, c = list(map(int,input().split()))
a -= 1; b-= 1
edges.append((a, b, -c))
dist = [inf] * N
dist[0] = 0
for _ in range(N-1):
for v, nv, w in edges:
if dist[nv] > dist[v] + w:
dist[nv] = dist[v] + w
is_update = [False] * N
for _ in range(N):
for v, nv, w in edges:
if dist[nv] > dist[v] + w:
dist[nv] = dist[v] + w
is_update[nv] = True
if is_update[v] is True:
is_update[nv] = True
if is_update[N-1] is True:
ans = "inf"
else:
ans = -dist[N-1]
print(ans)
|
inf = float('inf')
# ベルマンフォード法
# 計算量O(VE) V:頂点数, E:辺の数
# [引数] n:頂点数, edges:辺集合, start:始点, end:終点
# [返り値] dist:startからの最短距離, exists_negative_cycle: 負閉路が存在するかどうか
def bellmanford(n : int, edges : list, start : int, goal : int) -> (list, bool):
dist = [inf] * n
dist[start] = 0
exist_negative_cycle = True
# 負閉路を含まないとき、頂点数nなら更新は高々n-1回で済む
for _ in range(N-1):
for v, nv, w in edges:
if dist[nv] > dist[v] + w:
dist[nv] = dist[v] + w
# (1)グラフに負閉路が含まれるときの検出
# N回目で更新があったとき、グラフは負閉路を含む
# for v, nv, w in edges:
# if dist[nv] > dist[v] + w:
# is_cycle = False
# (2)startとendのパスに負閉路が含まれるときの検出
is_updated = [False] * n
for _ in range(N):
for v, nv, w in edges:
if dist[nv] > dist[v] + w:
dist[nv] = dist[v] + w
is_updated[nv] = True
if is_updated[v] is True:
is_updated[nv] = True
exist_negative_cycle = is_updated[goal]
return dist, exist_negative_cycle
N, M = list(map(int,input().split()))
edges = []
for _ in range(M):
a, b, c = list(map(int,input().split()))
a -= 1; b -= 1
edges.append((a, b, -c))
dist, exist_negative_cycle = bellmanford(N, edges, 0, N-1)
if exist_negative_cycle is True:
ans = "inf"
else:
ans = -dist[N-1]
print(ans)
| 31 | 52 | 668 | 1,388 |
inf = float("inf")
N, M = list(map(int, input().split()))
edges = []
for _ in range(M):
a, b, c = list(map(int, input().split()))
a -= 1
b -= 1
edges.append((a, b, -c))
dist = [inf] * N
dist[0] = 0
for _ in range(N - 1):
for v, nv, w in edges:
if dist[nv] > dist[v] + w:
dist[nv] = dist[v] + w
is_update = [False] * N
for _ in range(N):
for v, nv, w in edges:
if dist[nv] > dist[v] + w:
dist[nv] = dist[v] + w
is_update[nv] = True
if is_update[v] is True:
is_update[nv] = True
if is_update[N - 1] is True:
ans = "inf"
else:
ans = -dist[N - 1]
print(ans)
|
inf = float("inf")
# ベルマンフォード法
# 計算量O(VE) V:頂点数, E:辺の数
# [引数] n:頂点数, edges:辺集合, start:始点, end:終点
# [返り値] dist:startからの最短距離, exists_negative_cycle: 負閉路が存在するかどうか
def bellmanford(n: int, edges: list, start: int, goal: int) -> (list, bool):
dist = [inf] * n
dist[start] = 0
exist_negative_cycle = True
# 負閉路を含まないとき、頂点数nなら更新は高々n-1回で済む
for _ in range(N - 1):
for v, nv, w in edges:
if dist[nv] > dist[v] + w:
dist[nv] = dist[v] + w
# (1)グラフに負閉路が含まれるときの検出
# N回目で更新があったとき、グラフは負閉路を含む
# for v, nv, w in edges:
# if dist[nv] > dist[v] + w:
# is_cycle = False
# (2)startとendのパスに負閉路が含まれるときの検出
is_updated = [False] * n
for _ in range(N):
for v, nv, w in edges:
if dist[nv] > dist[v] + w:
dist[nv] = dist[v] + w
is_updated[nv] = True
if is_updated[v] is True:
is_updated[nv] = True
exist_negative_cycle = is_updated[goal]
return dist, exist_negative_cycle
N, M = list(map(int, input().split()))
edges = []
for _ in range(M):
a, b, c = list(map(int, input().split()))
a -= 1
b -= 1
edges.append((a, b, -c))
dist, exist_negative_cycle = bellmanford(N, edges, 0, N - 1)
if exist_negative_cycle is True:
ans = "inf"
else:
ans = -dist[N - 1]
print(ans)
| false | 40.384615 |
[
"+# ベルマンフォード法",
"+# 計算量O(VE) V:頂点数, E:辺の数",
"+# [引数] n:頂点数, edges:辺集合, start:始点, end:終点",
"+# [返り値] dist:startからの最短距離, exists_negative_cycle: 負閉路が存在するかどうか",
"+def bellmanford(n: int, edges: list, start: int, goal: int) -> (list, bool):",
"+ dist = [inf] * n",
"+ dist[start] = 0",
"+ exist_negative_cycle = True",
"+ # 負閉路を含まないとき、頂点数nなら更新は高々n-1回で済む",
"+ for _ in range(N - 1):",
"+ for v, nv, w in edges:",
"+ if dist[nv] > dist[v] + w:",
"+ dist[nv] = dist[v] + w",
"+ # (1)グラフに負閉路が含まれるときの検出",
"+ # N回目で更新があったとき、グラフは負閉路を含む",
"+ # for v, nv, w in edges:",
"+ # if dist[nv] > dist[v] + w:",
"+ # is_cycle = False",
"+ # (2)startとendのパスに負閉路が含まれるときの検出",
"+ is_updated = [False] * n",
"+ for _ in range(N):",
"+ for v, nv, w in edges:",
"+ if dist[nv] > dist[v] + w:",
"+ dist[nv] = dist[v] + w",
"+ is_updated[nv] = True",
"+ if is_updated[v] is True:",
"+ is_updated[nv] = True",
"+ exist_negative_cycle = is_updated[goal]",
"+ return dist, exist_negative_cycle",
"+",
"+",
"-dist = [inf] * N",
"-dist[0] = 0",
"-for _ in range(N - 1):",
"- for v, nv, w in edges:",
"- if dist[nv] > dist[v] + w:",
"- dist[nv] = dist[v] + w",
"-is_update = [False] * N",
"-for _ in range(N):",
"- for v, nv, w in edges:",
"- if dist[nv] > dist[v] + w:",
"- dist[nv] = dist[v] + w",
"- is_update[nv] = True",
"- if is_update[v] is True:",
"- is_update[nv] = True",
"-if is_update[N - 1] is True:",
"+dist, exist_negative_cycle = bellmanford(N, edges, 0, N - 1)",
"+if exist_negative_cycle is True:"
] | false | 0.037529 | 0.081098 | 0.462758 |
[
"s956509180",
"s648846903"
] |
u191214791
|
p03611
|
python
|
s605922226
|
s544034225
| 243 | 224 | 27,784 | 27,780 |
Accepted
|
Accepted
| 7.82 |
# encoding: "utf-8"
from collections import defaultdict
from functools import reduce
from itertools import groupby, chain
class Stdin:
@staticmethod
def read_line(converter=str):
return [converter(x) for x in input().split()]
@staticmethod
def read_lines(n, converter=str):
result = list()
for _ in range(n):
result.append(Stdin.read_line(converter))
return result
@staticmethod
def convert(data, converter):
assert(len(data) == len(converter))
return tuple(map(lambda x, f: f(x), data, converter))
@staticmethod
def convert_lines(datas, n, converter):
return [converter(data, n, converter) for data in datas]
def main():
_ = eval(input())
xs = Stdin.read_line(converter=int)
ys = chain.from_iterable([[x-1, x, x+1] for x in xs])
ys = sorted(list(ys))
m = max([len([1 for _ in x]) for (i, x) in groupby(ys)])
print(m)
if __name__ == "__main__":
main()
|
# encoding: "utf-8"
from collections import defaultdict
from functools import reduce
from itertools import groupby, chain
class Stdin:
@staticmethod
def read_line(converter=str):
return [converter(x) for x in input().split()]
@staticmethod
def read_lines(n, converter=str):
result = list()
for _ in range(n):
result.append(Stdin.read_line(converter))
return result
@staticmethod
def convert(data, converter):
assert(len(data) == len(converter))
return tuple(map(lambda x, f: f(x), data, converter))
@staticmethod
def convert_lines(datas, n, converter):
return [converter(data, n, converter) for data in datas]
def main():
_ = eval(input())
xs = Stdin.read_line(converter=int)
ys = chain.from_iterable([[x-1, x, x+1] for x in xs])
ys = sorted(list(ys))
cnt = 0
m = 0
prev = ys[0]
for y in ys:
if y == prev:
cnt += 1
else:
if m < cnt:
m = cnt
prev = y
cnt = 1
print(m)
if __name__ == "__main__":
main()
| 37 | 47 | 1,024 | 1,175 |
# encoding: "utf-8"
from collections import defaultdict
from functools import reduce
from itertools import groupby, chain
class Stdin:
@staticmethod
def read_line(converter=str):
return [converter(x) for x in input().split()]
@staticmethod
def read_lines(n, converter=str):
result = list()
for _ in range(n):
result.append(Stdin.read_line(converter))
return result
@staticmethod
def convert(data, converter):
assert len(data) == len(converter)
return tuple(map(lambda x, f: f(x), data, converter))
@staticmethod
def convert_lines(datas, n, converter):
return [converter(data, n, converter) for data in datas]
def main():
_ = eval(input())
xs = Stdin.read_line(converter=int)
ys = chain.from_iterable([[x - 1, x, x + 1] for x in xs])
ys = sorted(list(ys))
m = max([len([1 for _ in x]) for (i, x) in groupby(ys)])
print(m)
if __name__ == "__main__":
main()
|
# encoding: "utf-8"
from collections import defaultdict
from functools import reduce
from itertools import groupby, chain
class Stdin:
@staticmethod
def read_line(converter=str):
return [converter(x) for x in input().split()]
@staticmethod
def read_lines(n, converter=str):
result = list()
for _ in range(n):
result.append(Stdin.read_line(converter))
return result
@staticmethod
def convert(data, converter):
assert len(data) == len(converter)
return tuple(map(lambda x, f: f(x), data, converter))
@staticmethod
def convert_lines(datas, n, converter):
return [converter(data, n, converter) for data in datas]
def main():
_ = eval(input())
xs = Stdin.read_line(converter=int)
ys = chain.from_iterable([[x - 1, x, x + 1] for x in xs])
ys = sorted(list(ys))
cnt = 0
m = 0
prev = ys[0]
for y in ys:
if y == prev:
cnt += 1
else:
if m < cnt:
m = cnt
prev = y
cnt = 1
print(m)
if __name__ == "__main__":
main()
| false | 21.276596 |
[
"- m = max([len([1 for _ in x]) for (i, x) in groupby(ys)])",
"+ cnt = 0",
"+ m = 0",
"+ prev = ys[0]",
"+ for y in ys:",
"+ if y == prev:",
"+ cnt += 1",
"+ else:",
"+ if m < cnt:",
"+ m = cnt",
"+ prev = y",
"+ cnt = 1"
] | false | 0.042876 | 0.034671 | 1.23667 |
[
"s605922226",
"s544034225"
] |
u754022296
|
p02838
|
python
|
s185385573
|
s517987776
| 1,996 | 332 | 38,884 | 62,716 |
Accepted
|
Accepted
| 83.37 |
import sys
read = sys.stdin.read
def main():
MOD = 10**9+7
n, *A = list(map(int, read().split()))
ans = 0
for j in range(61):
c = 0
for i in A:
if i>>j & 1:
c += 1
ans += 2**j*((n-c)*c)
ans %= MOD
print((ans%MOD))
if __name__ == "__main__":
main()
|
import sys
input = sys.stdin.readline
import numpy as np
def main():
MOD = 10**9+7
n = int(eval(input()))
A = np.array(input().split(), dtype=np.int64)
ans = 0
for j in range(61):
X = A>>j & 1
t = np.count_nonzero(X)
ans += pow(2, j, MOD) * t * (n-t) % MOD
print((ans%MOD))
if __name__ == "__main__":
main()
| 18 | 18 | 302 | 347 |
import sys
read = sys.stdin.read
def main():
MOD = 10**9 + 7
n, *A = list(map(int, read().split()))
ans = 0
for j in range(61):
c = 0
for i in A:
if i >> j & 1:
c += 1
ans += 2**j * ((n - c) * c)
ans %= MOD
print((ans % MOD))
if __name__ == "__main__":
main()
|
import sys
input = sys.stdin.readline
import numpy as np
def main():
MOD = 10**9 + 7
n = int(eval(input()))
A = np.array(input().split(), dtype=np.int64)
ans = 0
for j in range(61):
X = A >> j & 1
t = np.count_nonzero(X)
ans += pow(2, j, MOD) * t * (n - t) % MOD
print((ans % MOD))
if __name__ == "__main__":
main()
| false | 0 |
[
"-read = sys.stdin.read",
"+input = sys.stdin.readline",
"+import numpy as np",
"- n, *A = list(map(int, read().split()))",
"+ n = int(eval(input()))",
"+ A = np.array(input().split(), dtype=np.int64)",
"- c = 0",
"- for i in A:",
"- if i >> j & 1:",
"- c += 1",
"- ans += 2**j * ((n - c) * c)",
"- ans %= MOD",
"+ X = A >> j & 1",
"+ t = np.count_nonzero(X)",
"+ ans += pow(2, j, MOD) * t * (n - t) % MOD"
] | false | 0.045386 | 0.277563 | 0.163517 |
[
"s185385573",
"s517987776"
] |
u395202850
|
p03731
|
python
|
s601673667
|
s412898388
| 150 | 129 | 26,708 | 26,836 |
Accepted
|
Accepted
| 14 |
n, t = list(map(int, input().split()))
tList = list(map(int, input().split()))
tSum = t
for i in range(n-1):
if tList[i+1] - tList[i] > t:
tSum += t
else:
tSum += tList[i+1] - tList[i]
print(tSum)
|
n, t = list(map(int, input().split()))
tList = list(map(int, input().split()))
tSum = t
for i in range(n-1):
tElapse = tList[i+1] - tList[i]
tSum += (t if tElapse > t else tElapse)
print(tSum)
| 11 | 9 | 227 | 205 |
n, t = list(map(int, input().split()))
tList = list(map(int, input().split()))
tSum = t
for i in range(n - 1):
if tList[i + 1] - tList[i] > t:
tSum += t
else:
tSum += tList[i + 1] - tList[i]
print(tSum)
|
n, t = list(map(int, input().split()))
tList = list(map(int, input().split()))
tSum = t
for i in range(n - 1):
tElapse = tList[i + 1] - tList[i]
tSum += t if tElapse > t else tElapse
print(tSum)
| false | 18.181818 |
[
"- if tList[i + 1] - tList[i] > t:",
"- tSum += t",
"- else:",
"- tSum += tList[i + 1] - tList[i]",
"+ tElapse = tList[i + 1] - tList[i]",
"+ tSum += t if tElapse > t else tElapse"
] | false | 0.038697 | 0.043536 | 0.888846 |
[
"s601673667",
"s412898388"
] |
u222668979
|
p03525
|
python
|
s599966237
|
s403269885
| 446 | 71 | 76,920 | 62,028 |
Accepted
|
Accepted
| 84.08 |
from collections import Counter
from itertools import product
def solve(LIST):
stmp = [i for i, li in enumerate(LIST * 2) if li == 1]
S = min(stmp[i] - stmp[i - 1] for i in range(1, len(stmp)))
return S
n = int(eval(input()))
d = Counter(list(map(int, input().split())) + [0])
if any(d[num] > (2 - (num in {0, 12})) for num in d):
print((0))
exit()
ans, cnt = [0] * 24, []
for num in d:
if (num in {0, 12}) and d[num] == 1:
ans[num] = 1
elif d[num] == 2:
ans[num], ans[24 - num] = 1, 1
elif d[num] == 1:
cnt.append(num)
s = 0
if len(cnt) == 0:
s = max(s, solve(ans))
for bit in product([1, -1], repeat=len(cnt)):
tmp = ans[:]
for bi, ci in zip(bit, cnt):
tmp[(ci - 12) * bi + 12] = 1
s = max(s, solve(tmp))
print(s)
|
n = int(eval(input()))
d = sorted(list(map(int, input().split())) + [0])
bit, cnt = [0] * 24, 1
for num in d:
bit[((num - 12) * cnt + 12) % 24] += 1
cnt *= -1
if any(i > 1 for i in bit):
print((0))
exit()
ans = [i for i, li in enumerate(bit * 2) if li == 1]
s = min(ans[i] - ans[i - 1] for i in range(1, len(ans)))
print(s)
| 35 | 14 | 830 | 347 |
from collections import Counter
from itertools import product
def solve(LIST):
stmp = [i for i, li in enumerate(LIST * 2) if li == 1]
S = min(stmp[i] - stmp[i - 1] for i in range(1, len(stmp)))
return S
n = int(eval(input()))
d = Counter(list(map(int, input().split())) + [0])
if any(d[num] > (2 - (num in {0, 12})) for num in d):
print((0))
exit()
ans, cnt = [0] * 24, []
for num in d:
if (num in {0, 12}) and d[num] == 1:
ans[num] = 1
elif d[num] == 2:
ans[num], ans[24 - num] = 1, 1
elif d[num] == 1:
cnt.append(num)
s = 0
if len(cnt) == 0:
s = max(s, solve(ans))
for bit in product([1, -1], repeat=len(cnt)):
tmp = ans[:]
for bi, ci in zip(bit, cnt):
tmp[(ci - 12) * bi + 12] = 1
s = max(s, solve(tmp))
print(s)
|
n = int(eval(input()))
d = sorted(list(map(int, input().split())) + [0])
bit, cnt = [0] * 24, 1
for num in d:
bit[((num - 12) * cnt + 12) % 24] += 1
cnt *= -1
if any(i > 1 for i in bit):
print((0))
exit()
ans = [i for i, li in enumerate(bit * 2) if li == 1]
s = min(ans[i] - ans[i - 1] for i in range(1, len(ans)))
print(s)
| false | 60 |
[
"-from collections import Counter",
"-from itertools import product",
"-",
"-",
"-def solve(LIST):",
"- stmp = [i for i, li in enumerate(LIST * 2) if li == 1]",
"- S = min(stmp[i] - stmp[i - 1] for i in range(1, len(stmp)))",
"- return S",
"-",
"-",
"-d = Counter(list(map(int, input().split())) + [0])",
"-if any(d[num] > (2 - (num in {0, 12})) for num in d):",
"+d = sorted(list(map(int, input().split())) + [0])",
"+bit, cnt = [0] * 24, 1",
"+for num in d:",
"+ bit[((num - 12) * cnt + 12) % 24] += 1",
"+ cnt *= -1",
"+if any(i > 1 for i in bit):",
"-ans, cnt = [0] * 24, []",
"-for num in d:",
"- if (num in {0, 12}) and d[num] == 1:",
"- ans[num] = 1",
"- elif d[num] == 2:",
"- ans[num], ans[24 - num] = 1, 1",
"- elif d[num] == 1:",
"- cnt.append(num)",
"-s = 0",
"-if len(cnt) == 0:",
"- s = max(s, solve(ans))",
"-for bit in product([1, -1], repeat=len(cnt)):",
"- tmp = ans[:]",
"- for bi, ci in zip(bit, cnt):",
"- tmp[(ci - 12) * bi + 12] = 1",
"- s = max(s, solve(tmp))",
"+ans = [i for i, li in enumerate(bit * 2) if li == 1]",
"+s = min(ans[i] - ans[i - 1] for i in range(1, len(ans)))"
] | false | 0.082846 | 0.057647 | 1.437121 |
[
"s599966237",
"s403269885"
] |
u761320129
|
p03575
|
python
|
s363610292
|
s578523335
| 22 | 19 | 3,064 | 3,064 |
Accepted
|
Accepted
| 13.64 |
N,M = list(map(int,input().split()))
src = [tuple([int(x)-1 for x in input().split()]) for i in range(M)]
parent = [i for i in range(N)]
rank = [0] * N
def root(a):
if parent[a] == a:
return a
else:
parent[a] = root(parent[a])
return parent[a]
def is_same(a,b):
return root(a) == root(b)
def unite(a,b):
ra = root(a)
rb = root(b)
if ra == rb: return
if rank[ra] < rank[rb]:
parent[ra] = rb
else:
parent[rb] = ra
if rank[ra] == rank[rb]: rank[ra] += 1
ans = 0
for i in range(M):
parent = [i for i in range(N)]
rank = [0] * N
for j,(a,b) in enumerate(src):
if i == j: continue
unite(a,b)
if len(set([root(i) for i in range(N)])) > 1:
ans += 1
print(ans)
|
N,M = list(map(int,input().split()))
es = [tuple([int(x)-1 for x in input().split()]) for i in range(M)]
gr = [[] for i in range(N)]
for i,(a,b) in enumerate(es):
gr[a].append((b,i))
gr[b].append((a,i))
ans = 0
for i in range(M):
visited = [0] * N
stack = [0]
while stack:
v = stack.pop()
visited[v] = 1
for to,e in gr[v]:
if visited[to]: continue
if i==e: continue
stack.append(to)
if sum(visited) < N:
ans += 1
print(ans)
| 33 | 21 | 803 | 533 |
N, M = list(map(int, input().split()))
src = [tuple([int(x) - 1 for x in input().split()]) for i in range(M)]
parent = [i for i in range(N)]
rank = [0] * N
def root(a):
if parent[a] == a:
return a
else:
parent[a] = root(parent[a])
return parent[a]
def is_same(a, b):
return root(a) == root(b)
def unite(a, b):
ra = root(a)
rb = root(b)
if ra == rb:
return
if rank[ra] < rank[rb]:
parent[ra] = rb
else:
parent[rb] = ra
if rank[ra] == rank[rb]:
rank[ra] += 1
ans = 0
for i in range(M):
parent = [i for i in range(N)]
rank = [0] * N
for j, (a, b) in enumerate(src):
if i == j:
continue
unite(a, b)
if len(set([root(i) for i in range(N)])) > 1:
ans += 1
print(ans)
|
N, M = list(map(int, input().split()))
es = [tuple([int(x) - 1 for x in input().split()]) for i in range(M)]
gr = [[] for i in range(N)]
for i, (a, b) in enumerate(es):
gr[a].append((b, i))
gr[b].append((a, i))
ans = 0
for i in range(M):
visited = [0] * N
stack = [0]
while stack:
v = stack.pop()
visited[v] = 1
for to, e in gr[v]:
if visited[to]:
continue
if i == e:
continue
stack.append(to)
if sum(visited) < N:
ans += 1
print(ans)
| false | 36.363636 |
[
"-src = [tuple([int(x) - 1 for x in input().split()]) for i in range(M)]",
"-parent = [i for i in range(N)]",
"-rank = [0] * N",
"-",
"-",
"-def root(a):",
"- if parent[a] == a:",
"- return a",
"- else:",
"- parent[a] = root(parent[a])",
"- return parent[a]",
"-",
"-",
"-def is_same(a, b):",
"- return root(a) == root(b)",
"-",
"-",
"-def unite(a, b):",
"- ra = root(a)",
"- rb = root(b)",
"- if ra == rb:",
"- return",
"- if rank[ra] < rank[rb]:",
"- parent[ra] = rb",
"- else:",
"- parent[rb] = ra",
"- if rank[ra] == rank[rb]:",
"- rank[ra] += 1",
"-",
"-",
"+es = [tuple([int(x) - 1 for x in input().split()]) for i in range(M)]",
"+gr = [[] for i in range(N)]",
"+for i, (a, b) in enumerate(es):",
"+ gr[a].append((b, i))",
"+ gr[b].append((a, i))",
"- parent = [i for i in range(N)]",
"- rank = [0] * N",
"- for j, (a, b) in enumerate(src):",
"- if i == j:",
"- continue",
"- unite(a, b)",
"- if len(set([root(i) for i in range(N)])) > 1:",
"+ visited = [0] * N",
"+ stack = [0]",
"+ while stack:",
"+ v = stack.pop()",
"+ visited[v] = 1",
"+ for to, e in gr[v]:",
"+ if visited[to]:",
"+ continue",
"+ if i == e:",
"+ continue",
"+ stack.append(to)",
"+ if sum(visited) < N:"
] | false | 0.078118 | 0.076138 | 1.025999 |
[
"s363610292",
"s578523335"
] |
u592248346
|
p03127
|
python
|
s452213647
|
s543229227
| 222 | 144 | 19,728 | 14,224 |
Accepted
|
Accepted
| 35.14 |
def gcd(a, b):
while b > 0:
a, b = b, a%b
return a
n = int(eval(input()))
enemy = list(set(map(int,input().split())))
if len(enemy)==1:
print((enemy[0]))
else:
enemy.sort()
min_n = 10**10
for i in range(len(enemy)-1):
min_n = min(min_n,gcd(enemy[i],enemy[i+1]))
print(min_n)
|
def gcd(x,y):
if x%y==0: return y
else: return gcd(y,x%y)
n = int(eval(input()))
a = list(map(int,input().split()))
a.sort()
ans = a[0]
for i in range(1,n):
ans = min(ans,gcd(ans,a[i]))
print(ans)
| 15 | 10 | 317 | 211 |
def gcd(a, b):
while b > 0:
a, b = b, a % b
return a
n = int(eval(input()))
enemy = list(set(map(int, input().split())))
if len(enemy) == 1:
print((enemy[0]))
else:
enemy.sort()
min_n = 10**10
for i in range(len(enemy) - 1):
min_n = min(min_n, gcd(enemy[i], enemy[i + 1]))
print(min_n)
|
def gcd(x, y):
if x % y == 0:
return y
else:
return gcd(y, x % y)
n = int(eval(input()))
a = list(map(int, input().split()))
a.sort()
ans = a[0]
for i in range(1, n):
ans = min(ans, gcd(ans, a[i]))
print(ans)
| false | 33.333333 |
[
"-def gcd(a, b):",
"- while b > 0:",
"- a, b = b, a % b",
"- return a",
"+def gcd(x, y):",
"+ if x % y == 0:",
"+ return y",
"+ else:",
"+ return gcd(y, x % y)",
"-enemy = list(set(map(int, input().split())))",
"-if len(enemy) == 1:",
"- print((enemy[0]))",
"-else:",
"- enemy.sort()",
"- min_n = 10**10",
"- for i in range(len(enemy) - 1):",
"- min_n = min(min_n, gcd(enemy[i], enemy[i + 1]))",
"- print(min_n)",
"+a = list(map(int, input().split()))",
"+a.sort()",
"+ans = a[0]",
"+for i in range(1, n):",
"+ ans = min(ans, gcd(ans, a[i]))",
"+print(ans)"
] | false | 0.03613 | 0.038588 | 0.936292 |
[
"s452213647",
"s543229227"
] |
u203843959
|
p04013
|
python
|
s353229181
|
s473490030
| 317 | 280 | 93,020 | 92,124 |
Accepted
|
Accepted
| 11.67 |
N,A=list(map(int,input().split()))
xlist=list(map(int,input().split()))
dp=[[[0]*(sum(xlist)+1) for _ in range(N+1)] for _ in range(N+1)]
dp[0][0][0]=1
for i in range(1,N+1):
dp[i][0][0]=1
for j in range(1,i+1):
for k in range(1,sum(xlist)+1):
dp[i][j][k]=dp[i-1][j][k]
if k-xlist[i-1]>=0:
dp[i][j][k]+=dp[i-1][j-1][k-xlist[i-1]]
#print(dp)
answer=0
for j in range(1,N+1):
if j*A>sum(xlist):
break
answer+=dp[N][j][j*A]
print(answer)
|
N,A=list(map(int,input().split()))
xlist=list(map(int,input().split()))
slist=[0]
for x in xlist:
slist.append(slist[-1]+x)
#print(slist)
dp=[[[0]*(sum(xlist)+1) for _ in range(N+1)] for _ in range(N+1)]
dp[0][0][0]=1
for i in range(1,N+1):
dp[i][0][0]=1
for j in range(1,i+1):
for k in range(1,slist[i]+1):
dp[i][j][k]=dp[i-1][j][k]
if k-xlist[i-1]>=0:
dp[i][j][k]+=dp[i-1][j-1][k-xlist[i-1]]
#print(dp)
answer=0
for j in range(1,N+1):
if j*A>sum(xlist):
break
answer+=dp[N][j][j*A]
print(answer)
| 21 | 26 | 488 | 560 |
N, A = list(map(int, input().split()))
xlist = list(map(int, input().split()))
dp = [[[0] * (sum(xlist) + 1) for _ in range(N + 1)] for _ in range(N + 1)]
dp[0][0][0] = 1
for i in range(1, N + 1):
dp[i][0][0] = 1
for j in range(1, i + 1):
for k in range(1, sum(xlist) + 1):
dp[i][j][k] = dp[i - 1][j][k]
if k - xlist[i - 1] >= 0:
dp[i][j][k] += dp[i - 1][j - 1][k - xlist[i - 1]]
# print(dp)
answer = 0
for j in range(1, N + 1):
if j * A > sum(xlist):
break
answer += dp[N][j][j * A]
print(answer)
|
N, A = list(map(int, input().split()))
xlist = list(map(int, input().split()))
slist = [0]
for x in xlist:
slist.append(slist[-1] + x)
# print(slist)
dp = [[[0] * (sum(xlist) + 1) for _ in range(N + 1)] for _ in range(N + 1)]
dp[0][0][0] = 1
for i in range(1, N + 1):
dp[i][0][0] = 1
for j in range(1, i + 1):
for k in range(1, slist[i] + 1):
dp[i][j][k] = dp[i - 1][j][k]
if k - xlist[i - 1] >= 0:
dp[i][j][k] += dp[i - 1][j - 1][k - xlist[i - 1]]
# print(dp)
answer = 0
for j in range(1, N + 1):
if j * A > sum(xlist):
break
answer += dp[N][j][j * A]
print(answer)
| false | 19.230769 |
[
"+slist = [0]",
"+for x in xlist:",
"+ slist.append(slist[-1] + x)",
"+# print(slist)",
"- for k in range(1, sum(xlist) + 1):",
"+ for k in range(1, slist[i] + 1):"
] | false | 0.081621 | 0.03973 | 2.054422 |
[
"s353229181",
"s473490030"
] |
u579699847
|
p03164
|
python
|
s111657218
|
s801200729
| 1,383 | 1,132 | 316,360 | 312,040 |
Accepted
|
Accepted
| 18.15 |
import itertools,sys
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
N,W = LI()
wv = [LI() for _ in range(N)]
V = N*10**3
dp = [[float('INF')]*(V+1) for _ in range(N+1)]
dp[0][0] = 0
for i,j in itertools.product(list(range(1,N+1)),list(range(V+1))):
w,v = wv[i-1]
if j-v>=0 and dp[i-1][j-v]+w<=W:
dp[i][j] = min(dp[i][j],dp[i-1][j-v]+w)
dp[i][j] = min(dp[i][j],dp[i-1][j])
print((max([i for i in range(V+1) if dp[-1][i]<=W])))
|
import sys
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
N,W = LI()
wv = [LI() for _ in range(N)]
V = N*10**3
dp = [[float('INF')]*(V+1) for _ in range(N+1)]
dp[0][0] = 0
for i in range(1,N+1):
w,v = wv[i-1]
for j in range(V+1):
if j-v>=0:
dp[i][j] = min(dp[i][j],dp[i-1][j-v]+w)
dp[i][j] = min(dp[i][j],dp[i-1][j])
print((max([i for i in range(V+1) if dp[-1][i]<=W])))
| 13 | 14 | 467 | 441 |
import itertools, sys
def LI():
return list(map(int, sys.stdin.readline().rstrip().split()))
N, W = LI()
wv = [LI() for _ in range(N)]
V = N * 10**3
dp = [[float("INF")] * (V + 1) for _ in range(N + 1)]
dp[0][0] = 0
for i, j in itertools.product(list(range(1, N + 1)), list(range(V + 1))):
w, v = wv[i - 1]
if j - v >= 0 and dp[i - 1][j - v] + w <= W:
dp[i][j] = min(dp[i][j], dp[i - 1][j - v] + w)
dp[i][j] = min(dp[i][j], dp[i - 1][j])
print((max([i for i in range(V + 1) if dp[-1][i] <= W])))
|
import sys
def LI():
return list(map(int, sys.stdin.readline().rstrip().split()))
N, W = LI()
wv = [LI() for _ in range(N)]
V = N * 10**3
dp = [[float("INF")] * (V + 1) for _ in range(N + 1)]
dp[0][0] = 0
for i in range(1, N + 1):
w, v = wv[i - 1]
for j in range(V + 1):
if j - v >= 0:
dp[i][j] = min(dp[i][j], dp[i - 1][j - v] + w)
dp[i][j] = min(dp[i][j], dp[i - 1][j])
print((max([i for i in range(V + 1) if dp[-1][i] <= W])))
| false | 7.142857 |
[
"-import itertools, sys",
"+import sys",
"-for i, j in itertools.product(list(range(1, N + 1)), list(range(V + 1))):",
"+for i in range(1, N + 1):",
"- if j - v >= 0 and dp[i - 1][j - v] + w <= W:",
"- dp[i][j] = min(dp[i][j], dp[i - 1][j - v] + w)",
"- dp[i][j] = min(dp[i][j], dp[i - 1][j])",
"+ for j in range(V + 1):",
"+ if j - v >= 0:",
"+ dp[i][j] = min(dp[i][j], dp[i - 1][j - v] + w)",
"+ dp[i][j] = min(dp[i][j], dp[i - 1][j])"
] | false | 0.085748 | 0.218556 | 0.392338 |
[
"s111657218",
"s801200729"
] |
u806976856
|
p03329
|
python
|
s204603893
|
s760782015
| 148 | 84 | 9,112 | 79,208 |
Accepted
|
Accepted
| 43.24 |
n=int(eval(input()))
def f(x):
ans=0
while x>0:
ans+=x%6
x=x//6
return ans
def g(x):
ans=0
while x>0:
ans+=x%9
x=x//9
return ans
ans=n
for i in range(n+1):
ans=min(ans,f(i)+g(n-i))
print(ans)
|
n = int(eval(input()))
dp = [10**6 for _ in range(n+1)]
dp[0] = 0
for i in range(n+1):
j6 = 1
while i+j6<=n:
dp[i+j6] = min(dp[i]+1,dp[i+j6])
j6 *= 6
j9 = 1
while i+j9<=n:
dp[i+j9] = min(dp[i]+1,dp[i+j9])
j9 *= 9
print((dp[n]))
| 17 | 15 | 262 | 284 |
n = int(eval(input()))
def f(x):
ans = 0
while x > 0:
ans += x % 6
x = x // 6
return ans
def g(x):
ans = 0
while x > 0:
ans += x % 9
x = x // 9
return ans
ans = n
for i in range(n + 1):
ans = min(ans, f(i) + g(n - i))
print(ans)
|
n = int(eval(input()))
dp = [10**6 for _ in range(n + 1)]
dp[0] = 0
for i in range(n + 1):
j6 = 1
while i + j6 <= n:
dp[i + j6] = min(dp[i] + 1, dp[i + j6])
j6 *= 6
j9 = 1
while i + j9 <= n:
dp[i + j9] = min(dp[i] + 1, dp[i + j9])
j9 *= 9
print((dp[n]))
| false | 11.764706 |
[
"-",
"-",
"-def f(x):",
"- ans = 0",
"- while x > 0:",
"- ans += x % 6",
"- x = x // 6",
"- return ans",
"-",
"-",
"-def g(x):",
"- ans = 0",
"- while x > 0:",
"- ans += x % 9",
"- x = x // 9",
"- return ans",
"-",
"-",
"-ans = n",
"+dp = [10**6 for _ in range(n + 1)]",
"+dp[0] = 0",
"- ans = min(ans, f(i) + g(n - i))",
"-print(ans)",
"+ j6 = 1",
"+ while i + j6 <= n:",
"+ dp[i + j6] = min(dp[i] + 1, dp[i + j6])",
"+ j6 *= 6",
"+ j9 = 1",
"+ while i + j9 <= n:",
"+ dp[i + j9] = min(dp[i] + 1, dp[i + j9])",
"+ j9 *= 9",
"+print((dp[n]))"
] | false | 0.184112 | 0.114763 | 1.604286 |
[
"s204603893",
"s760782015"
] |
u490553751
|
p03575
|
python
|
s139683873
|
s440933955
| 32 | 25 | 3,444 | 3,316 |
Accepted
|
Accepted
| 21.88 |
N,M=[int(i) for i in input().split()]
graph = [[] for _ in range(N+1)]
from collections import deque
aa = [0] * M
bb = [0] * M
ans = 0
for i in range(M):
a,b = [int(j) for j in input().split()]
graph[a].append(b)
graph[b].append(a)
aa[i] = a
bb[i] = b
import copy
grapha = copy.deepcopy(graph)
for k in range(M):
graph[aa[k]].remove(bb[k])
graph[bb[k]].remove(aa[k])
seen = [False] * (N+1)
from collections import deque
que = deque()
que.append(1)
while len(que) != 0:
x = que.popleft()
seen[x] = True
for i in graph[x]:
if seen[i]:
continue
que.append(i)
seen[i] = True
for l in range(1,N+1):
if seen[l]:
continue
ans +=1
break
graph = copy.deepcopy(grapha)
print(ans)
|
#template
def inputlist(): return [int(j) for j in input().split()]
from collections import Counter
#template
#issueから始める
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]
N,M = inputlist()
ans = 0
ab = [0]*M
for i in range(M):
ab[i] = inputlist()
for i in range(M):
uf = UnionFind(N)
for j in range(M):
if j == i:
continue
uf.union(ab[j][0]-1,ab[j][1]-1)
if len(uf.roots()) != 1:
ans +=1
print(ans)
| 36 | 56 | 872 | 1,341 |
N, M = [int(i) for i in input().split()]
graph = [[] for _ in range(N + 1)]
from collections import deque
aa = [0] * M
bb = [0] * M
ans = 0
for i in range(M):
a, b = [int(j) for j in input().split()]
graph[a].append(b)
graph[b].append(a)
aa[i] = a
bb[i] = b
import copy
grapha = copy.deepcopy(graph)
for k in range(M):
graph[aa[k]].remove(bb[k])
graph[bb[k]].remove(aa[k])
seen = [False] * (N + 1)
from collections import deque
que = deque()
que.append(1)
while len(que) != 0:
x = que.popleft()
seen[x] = True
for i in graph[x]:
if seen[i]:
continue
que.append(i)
seen[i] = True
for l in range(1, N + 1):
if seen[l]:
continue
ans += 1
break
graph = copy.deepcopy(grapha)
print(ans)
|
# template
def inputlist():
return [int(j) for j in input().split()]
from collections import Counter
# template
# issueから始める
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]
N, M = inputlist()
ans = 0
ab = [0] * M
for i in range(M):
ab[i] = inputlist()
for i in range(M):
uf = UnionFind(N)
for j in range(M):
if j == i:
continue
uf.union(ab[j][0] - 1, ab[j][1] - 1)
if len(uf.roots()) != 1:
ans += 1
print(ans)
| false | 35.714286 |
[
"-N, M = [int(i) for i in input().split()]",
"-graph = [[] for _ in range(N + 1)]",
"-from collections import deque",
"+# template",
"+def inputlist():",
"+ return [int(j) for j in input().split()]",
"-aa = [0] * M",
"-bb = [0] * M",
"+",
"+from collections import Counter",
"+",
"+# template",
"+# issueから始める",
"+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]",
"+",
"+",
"+N, M = inputlist()",
"+ab = [0] * M",
"- a, b = [int(j) for j in input().split()]",
"- graph[a].append(b)",
"- graph[b].append(a)",
"- aa[i] = a",
"- bb[i] = b",
"-import copy",
"-",
"-grapha = copy.deepcopy(graph)",
"-for k in range(M):",
"- graph[aa[k]].remove(bb[k])",
"- graph[bb[k]].remove(aa[k])",
"- seen = [False] * (N + 1)",
"- from collections import deque",
"-",
"- que = deque()",
"- que.append(1)",
"- while len(que) != 0:",
"- x = que.popleft()",
"- seen[x] = True",
"- for i in graph[x]:",
"- if seen[i]:",
"- continue",
"- que.append(i)",
"- seen[i] = True",
"- for l in range(1, N + 1):",
"- if seen[l]:",
"+ ab[i] = inputlist()",
"+for i in range(M):",
"+ uf = UnionFind(N)",
"+ for j in range(M):",
"+ if j == i:",
"+ uf.union(ab[j][0] - 1, ab[j][1] - 1)",
"+ if len(uf.roots()) != 1:",
"- break",
"- graph = copy.deepcopy(grapha)"
] | false | 0.033482 | 0.039093 | 0.856469 |
[
"s139683873",
"s440933955"
] |
u756388720
|
p03836
|
python
|
s523816999
|
s452214904
| 31 | 17 | 4,468 | 3,064 |
Accepted
|
Accepted
| 45.16 |
sx, sy, tx, ty = map(int, input().split())
def path(x, y, gx, gy):
u = gy - y
if u > 0:
for i in range(u):
print('U', end='')
elif u < 0:
for i in range(-u):
print('D', end='')
r = gx - x
if r > 0:
for i in range(r):
print('R', end='')
elif r < 0:
for i in range(-r):
print('L', end='')
path(sx,sy,tx,ty)
path(tx,ty,sx,sy)
print('L', end='')
path(sx-1,sy,tx,ty+1)
print('D', end='')
print('R', end='')
path(tx+1,ty,sx,sy-1)
print('U')
|
sx, sy, tx, ty = list(map(int, input().split()))
def path(sx, sy, tx, ty):
res = ''
y = ty - sy
res += abs(y) * ('U' if y > 0 else 'D')
x = tx - sx
res += abs(x) * ('R' if x > 0 else 'L')
return res
ans = ''
ans += path(sx, sy ,tx ,ty)
ans += path(tx, ty, sx, sy)
ans += 'L'
ans += path(sx - 1, sy, tx, ty + 1)
ans += 'DR'
ans += path(tx + 1, ty, sx, sy - 1)
ans += 'U'
print(ans)
| 26 | 19 | 514 | 407 |
sx, sy, tx, ty = map(int, input().split())
def path(x, y, gx, gy):
u = gy - y
if u > 0:
for i in range(u):
print("U", end="")
elif u < 0:
for i in range(-u):
print("D", end="")
r = gx - x
if r > 0:
for i in range(r):
print("R", end="")
elif r < 0:
for i in range(-r):
print("L", end="")
path(sx, sy, tx, ty)
path(tx, ty, sx, sy)
print("L", end="")
path(sx - 1, sy, tx, ty + 1)
print("D", end="")
print("R", end="")
path(tx + 1, ty, sx, sy - 1)
print("U")
|
sx, sy, tx, ty = list(map(int, input().split()))
def path(sx, sy, tx, ty):
res = ""
y = ty - sy
res += abs(y) * ("U" if y > 0 else "D")
x = tx - sx
res += abs(x) * ("R" if x > 0 else "L")
return res
ans = ""
ans += path(sx, sy, tx, ty)
ans += path(tx, ty, sx, sy)
ans += "L"
ans += path(sx - 1, sy, tx, ty + 1)
ans += "DR"
ans += path(tx + 1, ty, sx, sy - 1)
ans += "U"
print(ans)
| false | 26.923077 |
[
"-sx, sy, tx, ty = map(int, input().split())",
"+sx, sy, tx, ty = list(map(int, input().split()))",
"-def path(x, y, gx, gy):",
"- u = gy - y",
"- if u > 0:",
"- for i in range(u):",
"- print(\"U\", end=\"\")",
"- elif u < 0:",
"- for i in range(-u):",
"- print(\"D\", end=\"\")",
"- r = gx - x",
"- if r > 0:",
"- for i in range(r):",
"- print(\"R\", end=\"\")",
"- elif r < 0:",
"- for i in range(-r):",
"- print(\"L\", end=\"\")",
"+def path(sx, sy, tx, ty):",
"+ res = \"\"",
"+ y = ty - sy",
"+ res += abs(y) * (\"U\" if y > 0 else \"D\")",
"+ x = tx - sx",
"+ res += abs(x) * (\"R\" if x > 0 else \"L\")",
"+ return res",
"-path(sx, sy, tx, ty)",
"-path(tx, ty, sx, sy)",
"-print(\"L\", end=\"\")",
"-path(sx - 1, sy, tx, ty + 1)",
"-print(\"D\", end=\"\")",
"-print(\"R\", end=\"\")",
"-path(tx + 1, ty, sx, sy - 1)",
"-print(\"U\")",
"+ans = \"\"",
"+ans += path(sx, sy, tx, ty)",
"+ans += path(tx, ty, sx, sy)",
"+ans += \"L\"",
"+ans += path(sx - 1, sy, tx, ty + 1)",
"+ans += \"DR\"",
"+ans += path(tx + 1, ty, sx, sy - 1)",
"+ans += \"U\"",
"+print(ans)"
] | false | 0.064542 | 0.084652 | 0.762445 |
[
"s523816999",
"s452214904"
] |
u608088992
|
p02773
|
python
|
s401284507
|
s431394263
| 885 | 282 | 45,400 | 36,836 |
Accepted
|
Accepted
| 68.14 |
import sys
def solve():
N = int(eval(input()))
word = dict()
for i in range(N):
s = eval(input())
if s in word: word[s] += 1
else: word[s] = 1
L = []
for key in word:
L.append((word[key], key))
L.sort(reverse = True)
maxs = L[0][0]
Ans = []
for num, s in L:
if num == maxs: Ans.append(s)
Ans.sort()
for a in Ans:
print(a)
return 0
if __name__ == "__main__":
solve()
|
import sys
from collections import defaultdict
def solve():
input = sys.stdin.readline
N = int(input())
sDict = defaultdict(int)
maxCount = 0
for i in range(N):
s = input().strip("\n")
sDict[s] += 1
maxCount = max(maxCount, sDict[s])
maxS = []
for key in sDict:
if sDict[key] == maxCount:
maxS.append(key)
maxS.sort()
print(*maxS, sep="\n")
return 0
if __name__ == "__main__":
solve()
| 26 | 23 | 482 | 497 |
import sys
def solve():
N = int(eval(input()))
word = dict()
for i in range(N):
s = eval(input())
if s in word:
word[s] += 1
else:
word[s] = 1
L = []
for key in word:
L.append((word[key], key))
L.sort(reverse=True)
maxs = L[0][0]
Ans = []
for num, s in L:
if num == maxs:
Ans.append(s)
Ans.sort()
for a in Ans:
print(a)
return 0
if __name__ == "__main__":
solve()
|
import sys
from collections import defaultdict
def solve():
input = sys.stdin.readline
N = int(input())
sDict = defaultdict(int)
maxCount = 0
for i in range(N):
s = input().strip("\n")
sDict[s] += 1
maxCount = max(maxCount, sDict[s])
maxS = []
for key in sDict:
if sDict[key] == maxCount:
maxS.append(key)
maxS.sort()
print(*maxS, sep="\n")
return 0
if __name__ == "__main__":
solve()
| false | 11.538462 |
[
"+from collections import defaultdict",
"- N = int(eval(input()))",
"- word = dict()",
"+ input = sys.stdin.readline",
"+ N = int(input())",
"+ sDict = defaultdict(int)",
"+ maxCount = 0",
"- s = eval(input())",
"- if s in word:",
"- word[s] += 1",
"- else:",
"- word[s] = 1",
"- L = []",
"- for key in word:",
"- L.append((word[key], key))",
"- L.sort(reverse=True)",
"- maxs = L[0][0]",
"- Ans = []",
"- for num, s in L:",
"- if num == maxs:",
"- Ans.append(s)",
"- Ans.sort()",
"- for a in Ans:",
"- print(a)",
"+ s = input().strip(\"\\n\")",
"+ sDict[s] += 1",
"+ maxCount = max(maxCount, sDict[s])",
"+ maxS = []",
"+ for key in sDict:",
"+ if sDict[key] == maxCount:",
"+ maxS.append(key)",
"+ maxS.sort()",
"+ print(*maxS, sep=\"\\n\")"
] | false | 0.035103 | 0.070427 | 0.498437 |
[
"s401284507",
"s431394263"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.