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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
u903005414
|
p03309
|
python
|
s741695893
|
s095896324
| 417
| 300
| 86,868
| 101,204
|
Accepted
|
Accepted
| 28.06
|
N = int(eval(input()))
A = list(map(int, input().split()))
def f(x):
v = 0
for i in range(len(A)):
v += abs(A[i] - (x + i + 1))
return v
left = -(10**9 + 2 * 10**5)
right = 10**9 + 2 * 10**5
v = 10**18
while left + 1 < right:
x = (left + right) // 2
# print('left right x', left, right, x)
a = f(x)
v = min(v, a)
if a <= f(x + 1):
right = x
elif f(x - 1) >= a:
left = x
# ans = f(left)
# print('left ans v', left, ans, v)
print(v)
|
N = int(eval(input()))
A = list(map(int, input().split()))
B = sorted([A[i] - i - 1 for i in range(len(A))])
# print('B', B)
def f(x):
v = 0
for i in range(len(B)):
v += abs(B[i] - x)
return v
if len(B) % 2 == 0:
b1 = B[len(B) // 2 - 1]
b2 = B[len(B) // 2]
ans = min(f(b1), f(b2))
else:
b = B[len(B) // 2]
ans = f(b)
print(ans)
| 27
| 21
| 516
| 386
|
N = int(eval(input()))
A = list(map(int, input().split()))
def f(x):
v = 0
for i in range(len(A)):
v += abs(A[i] - (x + i + 1))
return v
left = -(10**9 + 2 * 10**5)
right = 10**9 + 2 * 10**5
v = 10**18
while left + 1 < right:
x = (left + right) // 2
# print('left right x', left, right, x)
a = f(x)
v = min(v, a)
if a <= f(x + 1):
right = x
elif f(x - 1) >= a:
left = x
# ans = f(left)
# print('left ans v', left, ans, v)
print(v)
|
N = int(eval(input()))
A = list(map(int, input().split()))
B = sorted([A[i] - i - 1 for i in range(len(A))])
# print('B', B)
def f(x):
v = 0
for i in range(len(B)):
v += abs(B[i] - x)
return v
if len(B) % 2 == 0:
b1 = B[len(B) // 2 - 1]
b2 = B[len(B) // 2]
ans = min(f(b1), f(b2))
else:
b = B[len(B) // 2]
ans = f(b)
print(ans)
| false
| 22.222222
|
[
"-",
"-",
"+B = sorted([A[i] - i - 1 for i in range(len(A))])",
"+# print('B', B)",
"- for i in range(len(A)):",
"- v += abs(A[i] - (x + i + 1))",
"+ for i in range(len(B)):",
"+ v += abs(B[i] - x)",
"-left = -(10**9 + 2 * 10**5)",
"-right = 10**9 + 2 * 10**5",
"-v = 10**18",
"-while left + 1 < right:",
"- x = (left + right) // 2",
"- # print('left right x', left, right, x)",
"- a = f(x)",
"- v = min(v, a)",
"- if a <= f(x + 1):",
"- right = x",
"- elif f(x - 1) >= a:",
"- left = x",
"-# ans = f(left)",
"-# print('left ans v', left, ans, v)",
"-print(v)",
"+if len(B) % 2 == 0:",
"+ b1 = B[len(B) // 2 - 1]",
"+ b2 = B[len(B) // 2]",
"+ ans = min(f(b1), f(b2))",
"+else:",
"+ b = B[len(B) // 2]",
"+ ans = f(b)",
"+print(ans)"
] | false
| 0.104974
| 0.066913
| 1.568805
|
[
"s741695893",
"s095896324"
] |
u962045495
|
p03168
|
python
|
s244758513
|
s793523257
| 168
| 106
| 97,564
| 33,896
|
Accepted
|
Accepted
| 36.9
|
#!/usr/bin/env python2
"""
This file is part of https://github.com/cheran-senthil/PyRival
Copyright 2019 Cheran Senthilkumar <[email protected]>
"""
import itertools
import math
import os
import sys
from atexit import register
from io import BytesIO
class dict(dict):
"""dict() -> new empty dictionary"""
def items(self):
"""D.items() -> a set-like object providing a view on D's items"""
return dict.iteritems(self)
def keys(self):
"""D.keys() -> a set-like object providing a view on D's keys"""
return dict.iterkeys(self)
def values(self):
"""D.values() -> an object providing a view on D's values"""
return dict.itervalues(self)
def gcd(x, y):
"""greatest common divisor of x and y"""
while y:
x, y = y, x % y
return x
range = xrange
filter = itertools.ifilter
map = itertools.imap
zip = itertools.izip
sys.stdin = BytesIO(os.read(0, os.fstat(0).st_size))
sys.stdout = BytesIO()
register(lambda: os.write(1, sys.stdout.getvalue()))
input = lambda: sys.stdin.readline().rstrip('\r\n')
n = int(eval(input()))
p = [float(i) for i in input().split()]
dp = [[0.0] * (n + 1) for _ in range(n)]
dp[0][0], dp[0][1] = 1 - p[0], p[0]
for i in range(1, n):
dp[i][0] = (1 - p[i]) * dp[i - 1][0]
for j in range(1, n + 1):
dp[i][j] = (p[i] * dp[i - 1][j - 1]) + ((1 - p[i]) * dp[i - 1][j])
print(sum(dp[-1][(n + 1) // 2:]))
|
#!/usr/bin/env python2
import os
import sys
from atexit import register
from io import BytesIO
range = xrange
sys.stdin = BytesIO(os.read(0, os.fstat(0).st_size))
sys.stdout = BytesIO()
register(lambda: os.write(1, sys.stdout.getvalue()))
input = lambda: sys.stdin.readline().rstrip('\r\n')
n = int(eval(input()))
p = [float(i) for i in input().split()]
dp = [0.0] * (n + 1)
dp[0], dp[1] = 1 - p[0], p[0]
for i in range(1, n):
_dp = [0.0] * (n + 1)
_dp[0] = (1 - p[i]) * dp[0]
for j in range(1, n + 1):
_dp[j] = (p[i] * dp[j - 1]) + ((1 - p[i]) * dp[j])
dp = _dp
print(sum(dp[(n + 1) // 2:]))
| 63
| 30
| 1,534
| 696
|
#!/usr/bin/env python2
"""
This file is part of https://github.com/cheran-senthil/PyRival
Copyright 2019 Cheran Senthilkumar <[email protected]>
"""
import itertools
import math
import os
import sys
from atexit import register
from io import BytesIO
class dict(dict):
"""dict() -> new empty dictionary"""
def items(self):
"""D.items() -> a set-like object providing a view on D's items"""
return dict.iteritems(self)
def keys(self):
"""D.keys() -> a set-like object providing a view on D's keys"""
return dict.iterkeys(self)
def values(self):
"""D.values() -> an object providing a view on D's values"""
return dict.itervalues(self)
def gcd(x, y):
"""greatest common divisor of x and y"""
while y:
x, y = y, x % y
return x
range = xrange
filter = itertools.ifilter
map = itertools.imap
zip = itertools.izip
sys.stdin = BytesIO(os.read(0, os.fstat(0).st_size))
sys.stdout = BytesIO()
register(lambda: os.write(1, sys.stdout.getvalue()))
input = lambda: sys.stdin.readline().rstrip("\r\n")
n = int(eval(input()))
p = [float(i) for i in input().split()]
dp = [[0.0] * (n + 1) for _ in range(n)]
dp[0][0], dp[0][1] = 1 - p[0], p[0]
for i in range(1, n):
dp[i][0] = (1 - p[i]) * dp[i - 1][0]
for j in range(1, n + 1):
dp[i][j] = (p[i] * dp[i - 1][j - 1]) + ((1 - p[i]) * dp[i - 1][j])
print(sum(dp[-1][(n + 1) // 2 :]))
|
#!/usr/bin/env python2
import os
import sys
from atexit import register
from io import BytesIO
range = xrange
sys.stdin = BytesIO(os.read(0, os.fstat(0).st_size))
sys.stdout = BytesIO()
register(lambda: os.write(1, sys.stdout.getvalue()))
input = lambda: sys.stdin.readline().rstrip("\r\n")
n = int(eval(input()))
p = [float(i) for i in input().split()]
dp = [0.0] * (n + 1)
dp[0], dp[1] = 1 - p[0], p[0]
for i in range(1, n):
_dp = [0.0] * (n + 1)
_dp[0] = (1 - p[i]) * dp[0]
for j in range(1, n + 1):
_dp[j] = (p[i] * dp[j - 1]) + ((1 - p[i]) * dp[j])
dp = _dp
print(sum(dp[(n + 1) // 2 :]))
| false
| 52.380952
|
[
"-\"\"\"",
"-This file is part of https://github.com/cheran-senthil/PyRival",
"-Copyright 2019 Cheran Senthilkumar <[email protected]>",
"-\"\"\"",
"-import itertools",
"-import math",
"-",
"-class dict(dict):",
"- \"\"\"dict() -> new empty dictionary\"\"\"",
"-",
"- def items(self):",
"- \"\"\"D.items() -> a set-like object providing a view on D's items\"\"\"",
"- return dict.iteritems(self)",
"-",
"- def keys(self):",
"- \"\"\"D.keys() -> a set-like object providing a view on D's keys\"\"\"",
"- return dict.iterkeys(self)",
"-",
"- def values(self):",
"- \"\"\"D.values() -> an object providing a view on D's values\"\"\"",
"- return dict.itervalues(self)",
"-",
"-",
"-def gcd(x, y):",
"- \"\"\"greatest common divisor of x and y\"\"\"",
"- while y:",
"- x, y = y, x % y",
"- return x",
"-",
"-",
"-filter = itertools.ifilter",
"-map = itertools.imap",
"-zip = itertools.izip",
"-dp = [[0.0] * (n + 1) for _ in range(n)]",
"-dp[0][0], dp[0][1] = 1 - p[0], p[0]",
"+dp = [0.0] * (n + 1)",
"+dp[0], dp[1] = 1 - p[0], p[0]",
"- dp[i][0] = (1 - p[i]) * dp[i - 1][0]",
"+ _dp = [0.0] * (n + 1)",
"+ _dp[0] = (1 - p[i]) * dp[0]",
"- dp[i][j] = (p[i] * dp[i - 1][j - 1]) + ((1 - p[i]) * dp[i - 1][j])",
"-print(sum(dp[-1][(n + 1) // 2 :]))",
"+ _dp[j] = (p[i] * dp[j - 1]) + ((1 - p[i]) * dp[j])",
"+ dp = _dp",
"+print(sum(dp[(n + 1) // 2 :]))"
] | false
| 0.064447
| 0.041851
| 1.53992
|
[
"s244758513",
"s793523257"
] |
u601426916
|
p02657
|
python
|
s536867722
|
s974898135
| 61
| 23
| 61,536
| 9,092
|
Accepted
|
Accepted
| 62.3
|
#A
A,B = list(map(int,input().split()))
print((A*B))
|
#C
A,B = list(map(float,input().split()))
A = int(A+0.1)
B = int(B*100+0.1)
print((int((A*B)/100)))
| 3
| 5
| 46
| 95
|
# A
A, B = list(map(int, input().split()))
print((A * B))
|
# C
A, B = list(map(float, input().split()))
A = int(A + 0.1)
B = int(B * 100 + 0.1)
print((int((A * B) / 100)))
| false
| 40
|
[
"-# A",
"-A, B = list(map(int, input().split()))",
"-print((A * B))",
"+# C",
"+A, B = list(map(float, input().split()))",
"+A = int(A + 0.1)",
"+B = int(B * 100 + 0.1)",
"+print((int((A * B) / 100)))"
] | false
| 0.037018
| 0.037419
| 0.989277
|
[
"s536867722",
"s974898135"
] |
u980753441
|
p02552
|
python
|
s387921909
|
s699037100
| 32
| 26
| 9,172
| 9,044
|
Accepted
|
Accepted
| 18.75
|
ans = [1, 0]
print((ans[int(eval(input()))]))
|
print((0 if bool(int(eval(input()))) else 1))
| 2
| 1
| 38
| 37
|
ans = [1, 0]
print((ans[int(eval(input()))]))
|
print((0 if bool(int(eval(input()))) else 1))
| false
| 50
|
[
"-ans = [1, 0]",
"-print((ans[int(eval(input()))]))",
"+print((0 if bool(int(eval(input()))) else 1))"
] | false
| 0.035855
| 0.040921
| 0.876192
|
[
"s387921909",
"s699037100"
] |
u793868662
|
p02945
|
python
|
s776373218
|
s325409235
| 170
| 26
| 38,256
| 9,092
|
Accepted
|
Accepted
| 84.71
|
a,b = list(map(int,input().split()))
c = max(a+b, a-b, a*b)
print(c)
|
def resolve():
a, b = list(map(int, input().split()))
print((max(a+b, a-b, a*b)))
resolve()
| 3
| 4
| 64
| 94
|
a, b = list(map(int, input().split()))
c = max(a + b, a - b, a * b)
print(c)
|
def resolve():
a, b = list(map(int, input().split()))
print((max(a + b, a - b, a * b)))
resolve()
| false
| 25
|
[
"-a, b = list(map(int, input().split()))",
"-c = max(a + b, a - b, a * b)",
"-print(c)",
"+def resolve():",
"+ a, b = list(map(int, input().split()))",
"+ print((max(a + b, a - b, a * b)))",
"+",
"+",
"+resolve()"
] | false
| 0.041532
| 0.041325
| 1.005015
|
[
"s776373218",
"s325409235"
] |
u814986259
|
p03699
|
python
|
s279363381
|
s267984795
| 24
| 17
| 3,316
| 3,060
|
Accepted
|
Accepted
| 29.17
|
N=int(eval(input()))
s=[int(eval(input())) for i in range(N)]
import collections
table=collections.defaultdict(int)
for x in s:
if x%10!=0:
table[x]+=1
if sum(s)%10==0:
if len(table)==0:
print((0))
else:
table=list(table.keys())
table.sort()
print((sum(s) - table[0]))
else:
print((sum(s)))
|
N = int(eval(input()))
s = [int(eval(input())) for i in range(N)]
S = sum(s)
if S % 10 != 0:
print(S)
else:
s.sort()
ans = S
flag = False
for x in s:
if x % 10 != 0:
ans -= x
flag = True
break
else:
continue
if flag:
print(ans)
else:
print((0))
| 16
| 21
| 315
| 360
|
N = int(eval(input()))
s = [int(eval(input())) for i in range(N)]
import collections
table = collections.defaultdict(int)
for x in s:
if x % 10 != 0:
table[x] += 1
if sum(s) % 10 == 0:
if len(table) == 0:
print((0))
else:
table = list(table.keys())
table.sort()
print((sum(s) - table[0]))
else:
print((sum(s)))
|
N = int(eval(input()))
s = [int(eval(input())) for i in range(N)]
S = sum(s)
if S % 10 != 0:
print(S)
else:
s.sort()
ans = S
flag = False
for x in s:
if x % 10 != 0:
ans -= x
flag = True
break
else:
continue
if flag:
print(ans)
else:
print((0))
| false
| 23.809524
|
[
"-import collections",
"-",
"-table = collections.defaultdict(int)",
"-for x in s:",
"- if x % 10 != 0:",
"- table[x] += 1",
"-if sum(s) % 10 == 0:",
"- if len(table) == 0:",
"+S = sum(s)",
"+if S % 10 != 0:",
"+ print(S)",
"+else:",
"+ s.sort()",
"+ ans = S",
"+ flag = False",
"+ for x in s:",
"+ if x % 10 != 0:",
"+ ans -= x",
"+ flag = True",
"+ break",
"+ else:",
"+ continue",
"+ if flag:",
"+ print(ans)",
"+ else:",
"- else:",
"- table = list(table.keys())",
"- table.sort()",
"- print((sum(s) - table[0]))",
"-else:",
"- print((sum(s)))"
] | false
| 0.037186
| 0.03742
| 0.993757
|
[
"s279363381",
"s267984795"
] |
u188827677
|
p03487
|
python
|
s383600145
|
s437831496
| 84
| 72
| 22,240
| 22,304
|
Accepted
|
Accepted
| 14.29
|
from collections import Counter
n = int(eval(input()))
a = list(map(int, input().split()))
count = Counter(a)
ans = 0
for i in list(count.items()):
if i[1] < i[0]: ans += i[1]
else: ans += abs(i[1]-i[0])
print(ans)
|
from collections import Counter
n = int(eval(input()))
a = list(map(int, input().split()))
count = Counter(a)
ans = 0
for k,v in list(count.items()):
if k < v: ans += v-k
elif v < k: ans += v
print(ans)
| 12
| 10
| 224
| 204
|
from collections import Counter
n = int(eval(input()))
a = list(map(int, input().split()))
count = Counter(a)
ans = 0
for i in list(count.items()):
if i[1] < i[0]:
ans += i[1]
else:
ans += abs(i[1] - i[0])
print(ans)
|
from collections import Counter
n = int(eval(input()))
a = list(map(int, input().split()))
count = Counter(a)
ans = 0
for k, v in list(count.items()):
if k < v:
ans += v - k
elif v < k:
ans += v
print(ans)
| false
| 16.666667
|
[
"-for i in list(count.items()):",
"- if i[1] < i[0]:",
"- ans += i[1]",
"- else:",
"- ans += abs(i[1] - i[0])",
"+for k, v in list(count.items()):",
"+ if k < v:",
"+ ans += v - k",
"+ elif v < k:",
"+ ans += v"
] | false
| 0.047336
| 0.114844
| 0.412179
|
[
"s383600145",
"s437831496"
] |
u871841829
|
p02899
|
python
|
s219988621
|
s881529224
| 209
| 92
| 23,352
| 92,032
|
Accepted
|
Accepted
| 55.98
|
N = int(eval(input()))
A = list(map(int, input().split()))
# AA = [ix, num for ix, num in enumerate(A)]
AA = []
for ix, num in enumerate(A):
AA.append((ix, num))
AA = sorted(AA, key=lambda x:x[1])
sbuf = ""
for student in AA:
sbuf+= str(student[0]+1) + " "
print(sbuf)
|
N = int(eval(input()))
A = list(map(int, input().split()))
ans = [0] * N
for i in range(N):
ans[A[i]-1] = i + 1
print((" ".join([str(x) for x in ans])))
| 17
| 8
| 287
| 158
|
N = int(eval(input()))
A = list(map(int, input().split()))
# AA = [ix, num for ix, num in enumerate(A)]
AA = []
for ix, num in enumerate(A):
AA.append((ix, num))
AA = sorted(AA, key=lambda x: x[1])
sbuf = ""
for student in AA:
sbuf += str(student[0] + 1) + " "
print(sbuf)
|
N = int(eval(input()))
A = list(map(int, input().split()))
ans = [0] * N
for i in range(N):
ans[A[i] - 1] = i + 1
print((" ".join([str(x) for x in ans])))
| false
| 52.941176
|
[
"-# AA = [ix, num for ix, num in enumerate(A)]",
"-AA = []",
"-for ix, num in enumerate(A):",
"- AA.append((ix, num))",
"-AA = sorted(AA, key=lambda x: x[1])",
"-sbuf = \"\"",
"-for student in AA:",
"- sbuf += str(student[0] + 1) + \" \"",
"-print(sbuf)",
"+ans = [0] * N",
"+for i in range(N):",
"+ ans[A[i] - 1] = i + 1",
"+print((\" \".join([str(x) for x in ans])))"
] | false
| 0.110633
| 0.072333
| 1.529486
|
[
"s219988621",
"s881529224"
] |
u218834617
|
p02678
|
python
|
s622871823
|
s825628883
| 525
| 413
| 47,412
| 34,236
|
Accepted
|
Accepted
| 21.33
|
import sys
from collections import *
N,M=list(map(int,input().split()))
adj=defaultdict(list)
for ln in sys.stdin:
A,B=list(map(int,ln.split()))
A,B=A-1,B-1
adj[A].append(B)
adj[B].append(A)
a={0:0}
que=deque([0])
while que:
u=que.popleft()
for v in adj[u]:
if v not in a:
a[v]=u
que.append(v)
if N-1-len(a)>0:
print('No')
else:
print('Yes')
for i in range(1,N):
print((a[i]+1))
|
import sys
from collections import *
N,M=list(map(int,input().split()))
adj=[[] for _ in range(N+1)]
for ln in sys.stdin:
A,B=list(map(int,ln.split()))
adj[A].append(B)
adj[B].append(A)
ans=[0]*(N+1)
ans[1]=1
que=deque([1])
while que:
A=que.popleft()
for B in adj[A]:
if ans[B]==0:
ans[B]=A
que.append(B)
print('Yes')
for i in range(2,N+1):
print((ans[i]))
| 26
| 23
| 469
| 424
|
import sys
from collections import *
N, M = list(map(int, input().split()))
adj = defaultdict(list)
for ln in sys.stdin:
A, B = list(map(int, ln.split()))
A, B = A - 1, B - 1
adj[A].append(B)
adj[B].append(A)
a = {0: 0}
que = deque([0])
while que:
u = que.popleft()
for v in adj[u]:
if v not in a:
a[v] = u
que.append(v)
if N - 1 - len(a) > 0:
print("No")
else:
print("Yes")
for i in range(1, N):
print((a[i] + 1))
|
import sys
from collections import *
N, M = list(map(int, input().split()))
adj = [[] for _ in range(N + 1)]
for ln in sys.stdin:
A, B = list(map(int, ln.split()))
adj[A].append(B)
adj[B].append(A)
ans = [0] * (N + 1)
ans[1] = 1
que = deque([1])
while que:
A = que.popleft()
for B in adj[A]:
if ans[B] == 0:
ans[B] = A
que.append(B)
print("Yes")
for i in range(2, N + 1):
print((ans[i]))
| false
| 11.538462
|
[
"-adj = defaultdict(list)",
"+adj = [[] for _ in range(N + 1)]",
"- A, B = A - 1, B - 1",
"-a = {0: 0}",
"-que = deque([0])",
"+ans = [0] * (N + 1)",
"+ans[1] = 1",
"+que = deque([1])",
"- u = que.popleft()",
"- for v in adj[u]:",
"- if v not in a:",
"- a[v] = u",
"- que.append(v)",
"-if N - 1 - len(a) > 0:",
"- print(\"No\")",
"-else:",
"- print(\"Yes\")",
"- for i in range(1, N):",
"- print((a[i] + 1))",
"+ A = que.popleft()",
"+ for B in adj[A]:",
"+ if ans[B] == 0:",
"+ ans[B] = A",
"+ que.append(B)",
"+print(\"Yes\")",
"+for i in range(2, N + 1):",
"+ print((ans[i]))"
] | false
| 0.064383
| 0.036229
| 1.777143
|
[
"s622871823",
"s825628883"
] |
u698176039
|
p02892
|
python
|
s459251014
|
s054702677
| 533
| 469
| 48,220
| 49,128
|
Accepted
|
Accepted
| 12.01
|
N = int(eval(input()))
S = [eval(input()) for _ in range(N)]
import sys
import copy
ans = 0
adj_list = [[]for _ in range(N)]
for i in range(N):
for j in range(i+1,N):
if int(S[i][j]):
adj_list[i].append(j)
adj_list[j].append(i)
for kk in range(N):
q = []
visited = [False] * N
cnt = 1
visited[kk] = True
q.append(kk)
VC = 1
while VC < N:
nextv = copy.copy(q)
q = []
nextv = list(set(nextv))
#子の要素同士の連結チェック
L = len(nextv)
for i in range(L):
if not(visited[nextv[i]]):
visited[nextv[i]] = True
VC += 1
for j in range(i+1,L):
if (int(S[nextv[i]][nextv[j]])):
print((-1))
sys.exit()
for nv in nextv:
for v in adj_list[nv]:
if not(visited[v]):
q.append(v)
cnt += 1
ans = max(ans,cnt-1)
#
print(ans)
|
import sys
sys.setrecursionlimit(10**8)
input = sys.stdin.readline
N = int(input())
S = [list(input()) for _ in range(N)]
edge = [[] for _ in range(N)]
for i in range(N):
for j in range(N):
if S[i][j]=='1':
edge[i].append(j)
ans = 0
import queue
for i in range(N):
q = queue.Queue()
q.put(i)
nums = [-1]*N
nums[i] = 1
while not q.empty():
v = q.get()
flag = True
for nv in edge[v]:
if nums[nv] == -1:
nums[nv] = nums[v] + 1
q.put(nv)
elif nums[nv]%2 != (nums[v]+1)%2:
flag = False
break
if not flag:
break
if flag:
ans = max(ans, max(nums))
print(ans) if ans != 0 else print(-1)
| 49
| 35
| 1,053
| 803
|
N = int(eval(input()))
S = [eval(input()) for _ in range(N)]
import sys
import copy
ans = 0
adj_list = [[] for _ in range(N)]
for i in range(N):
for j in range(i + 1, N):
if int(S[i][j]):
adj_list[i].append(j)
adj_list[j].append(i)
for kk in range(N):
q = []
visited = [False] * N
cnt = 1
visited[kk] = True
q.append(kk)
VC = 1
while VC < N:
nextv = copy.copy(q)
q = []
nextv = list(set(nextv))
# 子の要素同士の連結チェック
L = len(nextv)
for i in range(L):
if not (visited[nextv[i]]):
visited[nextv[i]] = True
VC += 1
for j in range(i + 1, L):
if int(S[nextv[i]][nextv[j]]):
print((-1))
sys.exit()
for nv in nextv:
for v in adj_list[nv]:
if not (visited[v]):
q.append(v)
cnt += 1
ans = max(ans, cnt - 1)
#
print(ans)
|
import sys
sys.setrecursionlimit(10**8)
input = sys.stdin.readline
N = int(input())
S = [list(input()) for _ in range(N)]
edge = [[] for _ in range(N)]
for i in range(N):
for j in range(N):
if S[i][j] == "1":
edge[i].append(j)
ans = 0
import queue
for i in range(N):
q = queue.Queue()
q.put(i)
nums = [-1] * N
nums[i] = 1
while not q.empty():
v = q.get()
flag = True
for nv in edge[v]:
if nums[nv] == -1:
nums[nv] = nums[v] + 1
q.put(nv)
elif nums[nv] % 2 != (nums[v] + 1) % 2:
flag = False
break
if not flag:
break
if flag:
ans = max(ans, max(nums))
print(ans) if ans != 0 else print(-1)
| false
| 28.571429
|
[
"-N = int(eval(input()))",
"-S = [eval(input()) for _ in range(N)]",
"-import copy",
"+sys.setrecursionlimit(10**8)",
"+input = sys.stdin.readline",
"+N = int(input())",
"+S = [list(input()) for _ in range(N)]",
"+edge = [[] for _ in range(N)]",
"+for i in range(N):",
"+ for j in range(N):",
"+ if S[i][j] == \"1\":",
"+ edge[i].append(j)",
"-adj_list = [[] for _ in range(N)]",
"+import queue",
"+",
"- for j in range(i + 1, N):",
"- if int(S[i][j]):",
"- adj_list[i].append(j)",
"- adj_list[j].append(i)",
"-for kk in range(N):",
"- q = []",
"- visited = [False] * N",
"- cnt = 1",
"- visited[kk] = True",
"- q.append(kk)",
"- VC = 1",
"- while VC < N:",
"- nextv = copy.copy(q)",
"- q = []",
"- nextv = list(set(nextv))",
"- # 子の要素同士の連結チェック",
"- L = len(nextv)",
"- for i in range(L):",
"- if not (visited[nextv[i]]):",
"- visited[nextv[i]] = True",
"- VC += 1",
"- for j in range(i + 1, L):",
"- if int(S[nextv[i]][nextv[j]]):",
"- print((-1))",
"- sys.exit()",
"- for nv in nextv:",
"- for v in adj_list[nv]:",
"- if not (visited[v]):",
"- q.append(v)",
"- cnt += 1",
"- ans = max(ans, cnt - 1)",
"-#",
"-print(ans)",
"+ q = queue.Queue()",
"+ q.put(i)",
"+ nums = [-1] * N",
"+ nums[i] = 1",
"+ while not q.empty():",
"+ v = q.get()",
"+ flag = True",
"+ for nv in edge[v]:",
"+ if nums[nv] == -1:",
"+ nums[nv] = nums[v] + 1",
"+ q.put(nv)",
"+ elif nums[nv] % 2 != (nums[v] + 1) % 2:",
"+ flag = False",
"+ break",
"+ if not flag:",
"+ break",
"+ if flag:",
"+ ans = max(ans, max(nums))",
"+print(ans) if ans != 0 else print(-1)"
] | false
| 0.04174
| 0.134984
| 0.309226
|
[
"s459251014",
"s054702677"
] |
u908763441
|
p02918
|
python
|
s342969821
|
s938089381
| 93
| 53
| 4,084
| 4,084
|
Accepted
|
Accepted
| 43.01
|
N, K = list(map(int, input().split()))
S = list(eval(input()))
count = 0
if N == 1:
print('0')
exit()
if S[0] == 'R' and S[1] == 'R':
count += 1
if S[N - 2] == 'L' and S[N - 1] == 'L':
count += 1
for i in range(1, N-1):
if [S[i - 1], S[i]] == ['L', 'L'] or [S[i], S[i + 1]] == ['R', 'R']:
count += 1
print((str(min(N - 1, count + K * 2))))
|
N, K = list(map(int, input().split()))
L = list(eval(input()))
L.insert(0, '')
L.append('')
num = 0
for n in range(1, N+1):
if L[n] == 'L' and L[n - 1] == 'L':
num += 1
if L[n] == 'R' and L[n + 1] == 'R':
num += 1
ans = min(num + K * 2, N - 1)
print((str(ans)))
| 14
| 12
| 366
| 282
|
N, K = list(map(int, input().split()))
S = list(eval(input()))
count = 0
if N == 1:
print("0")
exit()
if S[0] == "R" and S[1] == "R":
count += 1
if S[N - 2] == "L" and S[N - 1] == "L":
count += 1
for i in range(1, N - 1):
if [S[i - 1], S[i]] == ["L", "L"] or [S[i], S[i + 1]] == ["R", "R"]:
count += 1
print((str(min(N - 1, count + K * 2))))
|
N, K = list(map(int, input().split()))
L = list(eval(input()))
L.insert(0, "")
L.append("")
num = 0
for n in range(1, N + 1):
if L[n] == "L" and L[n - 1] == "L":
num += 1
if L[n] == "R" and L[n + 1] == "R":
num += 1
ans = min(num + K * 2, N - 1)
print((str(ans)))
| false
| 14.285714
|
[
"-S = list(eval(input()))",
"-count = 0",
"-if N == 1:",
"- print(\"0\")",
"- exit()",
"-if S[0] == \"R\" and S[1] == \"R\":",
"- count += 1",
"-if S[N - 2] == \"L\" and S[N - 1] == \"L\":",
"- count += 1",
"-for i in range(1, N - 1):",
"- if [S[i - 1], S[i]] == [\"L\", \"L\"] or [S[i], S[i + 1]] == [\"R\", \"R\"]:",
"- count += 1",
"-print((str(min(N - 1, count + K * 2))))",
"+L = list(eval(input()))",
"+L.insert(0, \"\")",
"+L.append(\"\")",
"+num = 0",
"+for n in range(1, N + 1):",
"+ if L[n] == \"L\" and L[n - 1] == \"L\":",
"+ num += 1",
"+ if L[n] == \"R\" and L[n + 1] == \"R\":",
"+ num += 1",
"+ans = min(num + K * 2, N - 1)",
"+print((str(ans)))"
] | false
| 0.129944
| 0.040475
| 3.210485
|
[
"s342969821",
"s938089381"
] |
u729133443
|
p03181
|
python
|
s225957576
|
s570600393
| 1,272
| 804
| 57,740
| 126,568
|
Accepted
|
Accepted
| 36.79
|
n,m,*t=list(map(int,open(0).read().split()))
e=[[]for _ in range(n)]
for a,b in zip(*[iter(t)]*2):
e[a-1]+=b-1,
e[b-1]+=a-1,
o=[]
s=[0]
f=[1]*n
for v in s:
o+=v,
f[v]=0
t=[]
for w in e[v]:
if f[w]:
s+=w,
t+=w,
e[v]=t
dp1=[0]*n
c=[[]for _ in range(n)]
for v in o[::-1]:
c1,c2=[1],[1]
for w in e[v]:
c1+=c1[-1]*(dp1[w]+1)%m,
for w in e[v][::-1]:
c2+=c2[-1]*(dp1[w]+1)%m,
dp1[v]=c1[-1]
c[v]=c1,c2[-2::-1]
dp2=[0]*n
dp2[0]=1
for v in o:
t=dp2[v]
for w,c1,c2 in zip(e[v],*c[v]):
dp2[w]=(t*c1*c2+1)%m
for dp1,dp2 in zip(dp1,dp2):
print((dp1*dp2%m))
|
n,m,*t=list(map(int,open(0).read().split()))
e=[[]for _ in range(n)]
for a,b in zip(*[iter(t)]*2):
e[a-1]+=b-1,
e[b-1]+=a-1,
o=[]
s=[0]
f=[1]*n
for v in s:
o+=v,
f[v]=0
t=[]
for w in e[v]:
if f[w]:
s+=w,
t+=w,
e[v]=t
dp1=[0]*n
c=[[]for _ in range(n)]
for v in o[::-1]:
x,y=[1],[1]
for w in e[v]:x+=x[-1]*(dp1[w]+1)%m,
for w in e[v][::-1]:y+=y[-1]*(dp1[w]+1)%m,
dp1[v]=x[-1]
c[v]=x,y[-2::-1]
dp2=[1]+[0]*n
for v in o:
for w,x,y in zip(e[v],*c[v]):dp2[w]=(dp2[v]*x*y+1)%m
for x,y in zip(dp1,dp2):print((x*y%m))
| 35
| 29
| 626
| 570
|
n, m, *t = list(map(int, open(0).read().split()))
e = [[] for _ in range(n)]
for a, b in zip(*[iter(t)] * 2):
e[a - 1] += (b - 1,)
e[b - 1] += (a - 1,)
o = []
s = [0]
f = [1] * n
for v in s:
o += (v,)
f[v] = 0
t = []
for w in e[v]:
if f[w]:
s += (w,)
t += (w,)
e[v] = t
dp1 = [0] * n
c = [[] for _ in range(n)]
for v in o[::-1]:
c1, c2 = [1], [1]
for w in e[v]:
c1 += (c1[-1] * (dp1[w] + 1) % m,)
for w in e[v][::-1]:
c2 += (c2[-1] * (dp1[w] + 1) % m,)
dp1[v] = c1[-1]
c[v] = c1, c2[-2::-1]
dp2 = [0] * n
dp2[0] = 1
for v in o:
t = dp2[v]
for w, c1, c2 in zip(e[v], *c[v]):
dp2[w] = (t * c1 * c2 + 1) % m
for dp1, dp2 in zip(dp1, dp2):
print((dp1 * dp2 % m))
|
n, m, *t = list(map(int, open(0).read().split()))
e = [[] for _ in range(n)]
for a, b in zip(*[iter(t)] * 2):
e[a - 1] += (b - 1,)
e[b - 1] += (a - 1,)
o = []
s = [0]
f = [1] * n
for v in s:
o += (v,)
f[v] = 0
t = []
for w in e[v]:
if f[w]:
s += (w,)
t += (w,)
e[v] = t
dp1 = [0] * n
c = [[] for _ in range(n)]
for v in o[::-1]:
x, y = [1], [1]
for w in e[v]:
x += (x[-1] * (dp1[w] + 1) % m,)
for w in e[v][::-1]:
y += (y[-1] * (dp1[w] + 1) % m,)
dp1[v] = x[-1]
c[v] = x, y[-2::-1]
dp2 = [1] + [0] * n
for v in o:
for w, x, y in zip(e[v], *c[v]):
dp2[w] = (dp2[v] * x * y + 1) % m
for x, y in zip(dp1, dp2):
print((x * y % m))
| false
| 17.142857
|
[
"- c1, c2 = [1], [1]",
"+ x, y = [1], [1]",
"- c1 += (c1[-1] * (dp1[w] + 1) % m,)",
"+ x += (x[-1] * (dp1[w] + 1) % m,)",
"- c2 += (c2[-1] * (dp1[w] + 1) % m,)",
"- dp1[v] = c1[-1]",
"- c[v] = c1, c2[-2::-1]",
"-dp2 = [0] * n",
"-dp2[0] = 1",
"+ y += (y[-1] * (dp1[w] + 1) % m,)",
"+ dp1[v] = x[-1]",
"+ c[v] = x, y[-2::-1]",
"+dp2 = [1] + [0] * n",
"- t = dp2[v]",
"- for w, c1, c2 in zip(e[v], *c[v]):",
"- dp2[w] = (t * c1 * c2 + 1) % m",
"-for dp1, dp2 in zip(dp1, dp2):",
"- print((dp1 * dp2 % m))",
"+ for w, x, y in zip(e[v], *c[v]):",
"+ dp2[w] = (dp2[v] * x * y + 1) % m",
"+for x, y in zip(dp1, dp2):",
"+ print((x * y % m))"
] | false
| 0.008297
| 0.061917
| 0.134007
|
[
"s225957576",
"s570600393"
] |
u588341295
|
p03172
|
python
|
s721890118
|
s983133600
| 935
| 777
| 146,500
| 135,768
|
Accepted
|
Accepted
| 16.9
|
# -*- coding: utf-8 -*-
import sys, re
from collections import deque, defaultdict, Counter
from math import sqrt, hypot, factorial, pi, sin, cos, radians
if sys.version_info.minor >= 5: from math import gcd
else: from fractions import gcd
from heapq import heappop, heappush, heapify, heappushpop
from bisect import bisect_left, bisect_right
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from functools import reduce, partial
from fractions import Fraction
from string import ascii_lowercase, ascii_uppercase, digits
def input(): return sys.stdin.readline().strip()
def ceil(a, b=1): return int(-(-a // b))
def round(x): return int((x*2+1) // 2)
def fermat(x, y, MOD): return x * pow(y, MOD-2, MOD) % MOD
def lcm(x, y): return (x * y) // gcd(x, y)
def lcm_list(nums): return reduce(lcm, nums, 1)
def gcd_list(nums): return reduce(gcd, nums, nums[0])
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7
N, K = MAP()
aN = LIST()
# dp[この子までの範囲で][飴を配る総数] = 場合の数
dp = [[0] * (K+1) for i in range(N+1)]
# 0番目まで(誰もいない)の範囲で0個配る場合の数は1通り
dp[0][0] = 1
for i in range(N):
sm = [0] * (K+2)
# 今回送るi行について累積和を取る
for j in range(1, K+2):
sm[j] = sm[j-1] + dp[i][j-1]
sm[j] %= MOD
for j in range(K+1):
# iが送る予定の長さに応じた区間和を取る
dp[i+1][j] = sm[j+1] - sm[max(j-aN[i], 0)]
dp[i+1][j] %= MOD
# for k in range(aN[i]+1):
# dp[i+1][j+k] += dp[i][j]
print((dp[N][K]))
|
# -*- coding: utf-8 -*-
import sys
from functools import reduce
def input(): return sys.stdin.readline().strip()
def ceil(a, b=1): return int(-(-a // b))
def round(x): return int((x*2+1) // 2)
def fermat(x, y, MOD): return x * pow(y, MOD-2, MOD) % MOD
def lcm(x, y): return (x * y) // gcd(x, y)
def lcm_list(nums): return reduce(lcm, nums, 1)
def gcd_list(nums): return reduce(gcd, nums, nums[0])
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7
N, K = MAP()
aN = LIST()
# dp[この子までの範囲で][飴を配る総数] = 場合の数
dp = [[0] * (K+1) for i in range(N+1)]
# 0番目まで(誰もいない)の範囲で0個配る場合の数は1通り
dp[0][0] = 1
for i in range(N):
sm = [0] * (K+2)
# 今回送るi行について累積和を取る
for j in range(1, K+2):
sm[j] = sm[j-1] + dp[i][j-1]
sm[j] %= MOD
for j in range(K+1):
# iが送る予定の長さに応じた区間和を取る
dp[i+1][j] = sm[j+1] - sm[max(j-aN[i], 0)]
dp[i+1][j] %= MOD
# for k in range(aN[i]+1):
# dp[i+1][j+k] += dp[i][j]
print((dp[N][K]))
| 51
| 39
| 1,685
| 1,115
|
# -*- coding: utf-8 -*-
import sys, re
from collections import deque, defaultdict, Counter
from math import sqrt, hypot, factorial, pi, sin, cos, radians
if sys.version_info.minor >= 5:
from math import gcd
else:
from fractions import gcd
from heapq import heappop, heappush, heapify, heappushpop
from bisect import bisect_left, bisect_right
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from functools import reduce, partial
from fractions import Fraction
from string import ascii_lowercase, ascii_uppercase, digits
def input():
return sys.stdin.readline().strip()
def ceil(a, b=1):
return int(-(-a // b))
def round(x):
return int((x * 2 + 1) // 2)
def fermat(x, y, MOD):
return x * pow(y, MOD - 2, MOD) % MOD
def lcm(x, y):
return (x * y) // gcd(x, y)
def lcm_list(nums):
return reduce(lcm, nums, 1)
def gcd_list(nums):
return reduce(gcd, nums, nums[0])
def INT():
return int(eval(input()))
def MAP():
return list(map(int, input().split()))
def LIST():
return list(map(int, input().split()))
sys.setrecursionlimit(10**9)
INF = float("inf")
MOD = 10**9 + 7
N, K = MAP()
aN = LIST()
# dp[この子までの範囲で][飴を配る総数] = 場合の数
dp = [[0] * (K + 1) for i in range(N + 1)]
# 0番目まで(誰もいない)の範囲で0個配る場合の数は1通り
dp[0][0] = 1
for i in range(N):
sm = [0] * (K + 2)
# 今回送るi行について累積和を取る
for j in range(1, K + 2):
sm[j] = sm[j - 1] + dp[i][j - 1]
sm[j] %= MOD
for j in range(K + 1):
# iが送る予定の長さに応じた区間和を取る
dp[i + 1][j] = sm[j + 1] - sm[max(j - aN[i], 0)]
dp[i + 1][j] %= MOD
# for k in range(aN[i]+1):
# dp[i+1][j+k] += dp[i][j]
print((dp[N][K]))
|
# -*- coding: utf-8 -*-
import sys
from functools import reduce
def input():
return sys.stdin.readline().strip()
def ceil(a, b=1):
return int(-(-a // b))
def round(x):
return int((x * 2 + 1) // 2)
def fermat(x, y, MOD):
return x * pow(y, MOD - 2, MOD) % MOD
def lcm(x, y):
return (x * y) // gcd(x, y)
def lcm_list(nums):
return reduce(lcm, nums, 1)
def gcd_list(nums):
return reduce(gcd, nums, nums[0])
def INT():
return int(eval(input()))
def MAP():
return list(map(int, input().split()))
def LIST():
return list(map(int, input().split()))
sys.setrecursionlimit(10**9)
INF = float("inf")
MOD = 10**9 + 7
N, K = MAP()
aN = LIST()
# dp[この子までの範囲で][飴を配る総数] = 場合の数
dp = [[0] * (K + 1) for i in range(N + 1)]
# 0番目まで(誰もいない)の範囲で0個配る場合の数は1通り
dp[0][0] = 1
for i in range(N):
sm = [0] * (K + 2)
# 今回送るi行について累積和を取る
for j in range(1, K + 2):
sm[j] = sm[j - 1] + dp[i][j - 1]
sm[j] %= MOD
for j in range(K + 1):
# iが送る予定の長さに応じた区間和を取る
dp[i + 1][j] = sm[j + 1] - sm[max(j - aN[i], 0)]
dp[i + 1][j] %= MOD
# for k in range(aN[i]+1):
# dp[i+1][j+k] += dp[i][j]
print((dp[N][K]))
| false
| 23.529412
|
[
"-import sys, re",
"-from collections import deque, defaultdict, Counter",
"-from math import sqrt, hypot, factorial, pi, sin, cos, radians",
"-",
"-if sys.version_info.minor >= 5:",
"- from math import gcd",
"-else:",
"- from fractions import gcd",
"-from heapq import heappop, heappush, heapify, heappushpop",
"-from bisect import bisect_left, bisect_right",
"-from itertools import permutations, combinations, product",
"-from operator import itemgetter, mul",
"-from copy import deepcopy",
"-from functools import reduce, partial",
"-from fractions import Fraction",
"-from string import ascii_lowercase, ascii_uppercase, digits",
"+import sys",
"+from functools import reduce"
] | false
| 0.74267
| 0.940022
| 0.790056
|
[
"s721890118",
"s983133600"
] |
u367130284
|
p03610
|
python
|
s073269645
|
s127865102
| 30
| 18
| 4,268
| 3,192
|
Accepted
|
Accepted
| 40
|
print(("".join([v for k,v in enumerate(list(eval(input()))) if k%2==0])))
|
print((input()[::2]))
| 1
| 1
| 65
| 19
|
print(("".join([v for k, v in enumerate(list(eval(input()))) if k % 2 == 0])))
|
print((input()[::2]))
| false
| 0
|
[
"-print((\"\".join([v for k, v in enumerate(list(eval(input()))) if k % 2 == 0])))",
"+print((input()[::2]))"
] | false
| 0.040451
| 0.042416
| 0.953667
|
[
"s073269645",
"s127865102"
] |
u746419473
|
p02897
|
python
|
s189310297
|
s783129594
| 19
| 17
| 2,940
| 2,940
|
Accepted
|
Accepted
| 10.53
|
n=int(eval(input()))
print(((n//2+1)/n if n%2==1 else (n//2)/n))
|
n = int(eval(input()))
print((sum([x%2 == 1 for x in range(1, n+1)])/n))
| 3
| 2
| 60
| 71
|
n = int(eval(input()))
print(((n // 2 + 1) / n if n % 2 == 1 else (n // 2) / n))
|
n = int(eval(input()))
print((sum([x % 2 == 1 for x in range(1, n + 1)]) / n))
| false
| 33.333333
|
[
"-print(((n // 2 + 1) / n if n % 2 == 1 else (n // 2) / n))",
"+print((sum([x % 2 == 1 for x in range(1, n + 1)]) / n))"
] | false
| 0.066691
| 0.068234
| 0.977374
|
[
"s189310297",
"s783129594"
] |
u556657484
|
p02641
|
python
|
s229086057
|
s157827420
| 22
| 19
| 9,228
| 9,244
|
Accepted
|
Accepted
| 13.64
|
X, N = list(map(int,input().split()))
if N == 0:
print(X)
exit()
else:
P = list(map(int,input().split()))
L = [i for i in range(0,102) if i not in P]
if X in L:
ANS = X
else:
L.append(X)
L = sorted(L)
n = L.index(X)
l = len(L) - 1
if (0 < n < l):
if (L[n+1]-L[n] < L[n] - L[n-1]):
ANS = L[n+1]
else:
ANS = L[n - 1]
elif (n == l):
ANS = L[l - 1]
print(ANS)
|
X, N = list(map(int,input().split()))
if N == 0:
print(X)
exit()
else:
P = list(map(int,input().split()))
L = [i for i in range(0,102) if i not in P]
if X in L:
ANS = X
else:
L.append(X)
L = sorted(L)
n = L.index(X)
if (L[n+1]-L[n] < L[n] - L[n-1]):
ANS = L[n+1]
else:
ANS = L[n - 1]
print(ANS)
| 26
| 20
| 466
| 361
|
X, N = list(map(int, input().split()))
if N == 0:
print(X)
exit()
else:
P = list(map(int, input().split()))
L = [i for i in range(0, 102) if i not in P]
if X in L:
ANS = X
else:
L.append(X)
L = sorted(L)
n = L.index(X)
l = len(L) - 1
if 0 < n < l:
if L[n + 1] - L[n] < L[n] - L[n - 1]:
ANS = L[n + 1]
else:
ANS = L[n - 1]
elif n == l:
ANS = L[l - 1]
print(ANS)
|
X, N = list(map(int, input().split()))
if N == 0:
print(X)
exit()
else:
P = list(map(int, input().split()))
L = [i for i in range(0, 102) if i not in P]
if X in L:
ANS = X
else:
L.append(X)
L = sorted(L)
n = L.index(X)
if L[n + 1] - L[n] < L[n] - L[n - 1]:
ANS = L[n + 1]
else:
ANS = L[n - 1]
print(ANS)
| false
| 23.076923
|
[
"- l = len(L) - 1",
"- if 0 < n < l:",
"- if L[n + 1] - L[n] < L[n] - L[n - 1]:",
"- ANS = L[n + 1]",
"- else:",
"- ANS = L[n - 1]",
"- elif n == l:",
"- ANS = L[l - 1]",
"+ if L[n + 1] - L[n] < L[n] - L[n - 1]:",
"+ ANS = L[n + 1]",
"+ else:",
"+ ANS = L[n - 1]"
] | false
| 0.040552
| 0.040983
| 0.989499
|
[
"s229086057",
"s157827420"
] |
u767797498
|
p02689
|
python
|
s963335581
|
s508743210
| 470
| 320
| 54,172
| 20,388
|
Accepted
|
Accepted
| 31.91
|
from collections import defaultdict
n,m=list(map(int,input().split()))
h=list(map(int,input().split()))
dd=defaultdict(set)
for i in range(m):
a,b=list(map(int,input().split()))
dd[a-1].add(b-1)
dd[b-1].add(a-1)
cnt=0
for i,hh in enumerate(h):
flg=True
for j in dd[i]:
if hh <= h[j]:
flg=False
break
if flg:
cnt+=1
print(cnt)
|
from collections import defaultdict
n,m=list(map(int,input().split()))
h=list(map(int,input().split()))
ma=[0 for _ in range(n)]
for _ in range(m):
a,b=list(map(int,input().split()))
ma[a-1]=max(ma[a-1],h[b-1])
ma[b-1]=max(ma[b-1],h[a-1])
cnt=0
for i,hh in enumerate(ma):
if h[i] > hh:
cnt+=1
print(cnt)
| 19
| 14
| 367
| 320
|
from collections import defaultdict
n, m = list(map(int, input().split()))
h = list(map(int, input().split()))
dd = defaultdict(set)
for i in range(m):
a, b = list(map(int, input().split()))
dd[a - 1].add(b - 1)
dd[b - 1].add(a - 1)
cnt = 0
for i, hh in enumerate(h):
flg = True
for j in dd[i]:
if hh <= h[j]:
flg = False
break
if flg:
cnt += 1
print(cnt)
|
from collections import defaultdict
n, m = list(map(int, input().split()))
h = list(map(int, input().split()))
ma = [0 for _ in range(n)]
for _ in range(m):
a, b = list(map(int, input().split()))
ma[a - 1] = max(ma[a - 1], h[b - 1])
ma[b - 1] = max(ma[b - 1], h[a - 1])
cnt = 0
for i, hh in enumerate(ma):
if h[i] > hh:
cnt += 1
print(cnt)
| false
| 26.315789
|
[
"-dd = defaultdict(set)",
"-for i in range(m):",
"+ma = [0 for _ in range(n)]",
"+for _ in range(m):",
"- dd[a - 1].add(b - 1)",
"- dd[b - 1].add(a - 1)",
"+ ma[a - 1] = max(ma[a - 1], h[b - 1])",
"+ ma[b - 1] = max(ma[b - 1], h[a - 1])",
"-for i, hh in enumerate(h):",
"- flg = True",
"- for j in dd[i]:",
"- if hh <= h[j]:",
"- flg = False",
"- break",
"- if flg:",
"+for i, hh in enumerate(ma):",
"+ if h[i] > hh:"
] | false
| 0.037785
| 0.038056
| 0.992889
|
[
"s963335581",
"s508743210"
] |
u316268279
|
p00481
|
python
|
s461830022
|
s585475198
| 17,780
| 15,230
| 38,332
| 38,348
|
Accepted
|
Accepted
| 14.34
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import heapq
import sys
def check_out_of_map(pos,H,W):
H = len(Map)
W = len(Map[0])
if pos[0] < 0 or pos[1] < 0:
return False
if pos[0] >= H or pos[1] >= W:
return False
return True
def bfs(s,g,Map,H,W):
queue = []
queue.append(s)
dist = [[-1 for i in range(W)] for j in range(H)]
direct = [(1,0),(-1,0),(0,1),(0,-1)]
count = 0
dist[s[0]][s[1]] = 0
while queue != []:
q = queue.pop(0)
if q == g:
return dist[q[0]][q[1]]
for i in range(4):
nextPos = (q[0]+direct[i][0],q[1]+direct[i][1])
if check_out_of_map(nextPos,H,W) and Map[nextPos[0]][nextPos[1]] != "X":
if dist[nextPos[0]][nextPos[1]] == -1:
dist[nextPos[0]][nextPos[1]] = dist[q[0]][q[1]] + 1
queue.append(nextPos)
H,W,N = list(map(int,input().split(" ")))
cheese_queue = []
Map = []
for i in range(H):
count = 0
line = []
while True:
char = sys.stdin.read(1)
if char == "S":
s = (i,count)
elif char.isnumeric():
heapq.heappush(cheese_queue,(int(char),(i,count)))
elif char == "\n":
break
line.append(char)
count += 1
Map.append(line)
count = 0
while cheese_queue != []:
q = heapq.heappop(cheese_queue)
count += bfs(s,q[1],Map,H,W)
s = q[1]
print(count)
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import heapq
import sys
def check_out_of_map(pos,H,W):
if pos[0] < 0 or pos[1] < 0:
return False
if pos[0] >= H or pos[1] >= W:
return False
return True
def bfs(s,g,Map,H,W):
queue = []
queue.append(s)
dist = [[-1 for i in range(W)] for j in range(H)]
direct = [(1,0),(-1,0),(0,1),(0,-1)]
count = 0
dist[s[0]][s[1]] = 0
while queue != []:
q = queue.pop(0)
if q == g:
return dist[q[0]][q[1]]
for i in range(4):
nextPos = (q[0]+direct[i][0],q[1]+direct[i][1])
if check_out_of_map(nextPos,H,W) and Map[nextPos[0]][nextPos[1]] != "X":
if dist[nextPos[0]][nextPos[1]] == -1:
dist[nextPos[0]][nextPos[1]] = dist[q[0]][q[1]] + 1
queue.append(nextPos)
H,W,N = list(map(int,input().split(" ")))
cheese_queue = []
Map = []
for i in range(H):
count = 0
line = []
while True:
char = sys.stdin.read(1)
if char == "S":
s = (i,count)
elif char.isnumeric():
heapq.heappush(cheese_queue,(int(char),(i,count)))
elif char == "\n":
break
line.append(char)
count += 1
Map.append(line)
count = 0
while cheese_queue != []:
q = heapq.heappop(cheese_queue)
count += bfs(s,q[1],Map,H,W)
s = q[1]
print(count)
| 58
| 55
| 1,506
| 1,465
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import heapq
import sys
def check_out_of_map(pos, H, W):
H = len(Map)
W = len(Map[0])
if pos[0] < 0 or pos[1] < 0:
return False
if pos[0] >= H or pos[1] >= W:
return False
return True
def bfs(s, g, Map, H, W):
queue = []
queue.append(s)
dist = [[-1 for i in range(W)] for j in range(H)]
direct = [(1, 0), (-1, 0), (0, 1), (0, -1)]
count = 0
dist[s[0]][s[1]] = 0
while queue != []:
q = queue.pop(0)
if q == g:
return dist[q[0]][q[1]]
for i in range(4):
nextPos = (q[0] + direct[i][0], q[1] + direct[i][1])
if check_out_of_map(nextPos, H, W) and Map[nextPos[0]][nextPos[1]] != "X":
if dist[nextPos[0]][nextPos[1]] == -1:
dist[nextPos[0]][nextPos[1]] = dist[q[0]][q[1]] + 1
queue.append(nextPos)
H, W, N = list(map(int, input().split(" ")))
cheese_queue = []
Map = []
for i in range(H):
count = 0
line = []
while True:
char = sys.stdin.read(1)
if char == "S":
s = (i, count)
elif char.isnumeric():
heapq.heappush(cheese_queue, (int(char), (i, count)))
elif char == "\n":
break
line.append(char)
count += 1
Map.append(line)
count = 0
while cheese_queue != []:
q = heapq.heappop(cheese_queue)
count += bfs(s, q[1], Map, H, W)
s = q[1]
print(count)
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import heapq
import sys
def check_out_of_map(pos, H, W):
if pos[0] < 0 or pos[1] < 0:
return False
if pos[0] >= H or pos[1] >= W:
return False
return True
def bfs(s, g, Map, H, W):
queue = []
queue.append(s)
dist = [[-1 for i in range(W)] for j in range(H)]
direct = [(1, 0), (-1, 0), (0, 1), (0, -1)]
count = 0
dist[s[0]][s[1]] = 0
while queue != []:
q = queue.pop(0)
if q == g:
return dist[q[0]][q[1]]
for i in range(4):
nextPos = (q[0] + direct[i][0], q[1] + direct[i][1])
if check_out_of_map(nextPos, H, W) and Map[nextPos[0]][nextPos[1]] != "X":
if dist[nextPos[0]][nextPos[1]] == -1:
dist[nextPos[0]][nextPos[1]] = dist[q[0]][q[1]] + 1
queue.append(nextPos)
H, W, N = list(map(int, input().split(" ")))
cheese_queue = []
Map = []
for i in range(H):
count = 0
line = []
while True:
char = sys.stdin.read(1)
if char == "S":
s = (i, count)
elif char.isnumeric():
heapq.heappush(cheese_queue, (int(char), (i, count)))
elif char == "\n":
break
line.append(char)
count += 1
Map.append(line)
count = 0
while cheese_queue != []:
q = heapq.heappop(cheese_queue)
count += bfs(s, q[1], Map, H, W)
s = q[1]
print(count)
| false
| 5.172414
|
[
"- H = len(Map)",
"- W = len(Map[0])"
] | false
| 0.039565
| 0.03365
| 1.175772
|
[
"s461830022",
"s585475198"
] |
u290563917
|
p03060
|
python
|
s710295195
|
s122824669
| 166
| 66
| 38,384
| 61,824
|
Accepted
|
Accepted
| 60.24
|
n = int(eval(input()))
v = [num for num in map(int, input().split())]
c = [num for num in map(int, input().split())]
ans = 0
for i in range(n):
val = v[i] - c[i]
if val > 0:
ans += val
print(ans)
|
n = int(eval(input()))
v = list(map(int, input().split()))
c = list(map(int, input().split()))
ans = 0
for i in range(n):
if v[i] > c[i]:
ans += v[i] - c[i]
print(ans)
| 12
| 9
| 211
| 176
|
n = int(eval(input()))
v = [num for num in map(int, input().split())]
c = [num for num in map(int, input().split())]
ans = 0
for i in range(n):
val = v[i] - c[i]
if val > 0:
ans += val
print(ans)
|
n = int(eval(input()))
v = list(map(int, input().split()))
c = list(map(int, input().split()))
ans = 0
for i in range(n):
if v[i] > c[i]:
ans += v[i] - c[i]
print(ans)
| false
| 25
|
[
"-v = [num for num in map(int, input().split())]",
"-c = [num for num in map(int, input().split())]",
"+v = list(map(int, input().split()))",
"+c = list(map(int, input().split()))",
"- val = v[i] - c[i]",
"- if val > 0:",
"- ans += val",
"+ if v[i] > c[i]:",
"+ ans += v[i] - c[i]"
] | false
| 0.095349
| 0.0478
| 1.99474
|
[
"s710295195",
"s122824669"
] |
u489959379
|
p02959
|
python
|
s223298972
|
s335895939
| 195
| 126
| 19,116
| 19,004
|
Accepted
|
Accepted
| 35.38
|
n = int(eval(input()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
ans = 0
for i in range(n):
left = min(a[i], b[i])
ans += left
a[i] -= left
b[i] -= left
right = min(a[i+1], b[i])
ans += right
a[i+1] -= right
b[i] -= right
print(ans)
|
import sys
sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n = int(eval(input()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
res = 0
for i in range(n):
if A[i] <= B[i]:
res += A[i]
B[i] -= A[i]
A[i] = 0
if A[i + 1] <= B[i]:
res += A[i + 1]
B[i] -= A[i + 1]
A[i + 1] = 0
else:
res += B[i]
A[i + 1] -= B[i]
B[i] = 0
else:
res += B[i]
A[i] -= B[i]
B[i] = 0
print(res)
if __name__ == '__main__':
resolve()
| 17
| 37
| 308
| 742
|
n = int(eval(input()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
ans = 0
for i in range(n):
left = min(a[i], b[i])
ans += left
a[i] -= left
b[i] -= left
right = min(a[i + 1], b[i])
ans += right
a[i + 1] -= right
b[i] -= right
print(ans)
|
import sys
sys.setrecursionlimit(10**7)
f_inf = float("inf")
mod = 10**9 + 7
def resolve():
n = int(eval(input()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
res = 0
for i in range(n):
if A[i] <= B[i]:
res += A[i]
B[i] -= A[i]
A[i] = 0
if A[i + 1] <= B[i]:
res += A[i + 1]
B[i] -= A[i + 1]
A[i + 1] = 0
else:
res += B[i]
A[i + 1] -= B[i]
B[i] = 0
else:
res += B[i]
A[i] -= B[i]
B[i] = 0
print(res)
if __name__ == "__main__":
resolve()
| false
| 54.054054
|
[
"-n = int(eval(input()))",
"-a = list(map(int, input().split()))",
"-b = list(map(int, input().split()))",
"-ans = 0",
"-for i in range(n):",
"- left = min(a[i], b[i])",
"- ans += left",
"- a[i] -= left",
"- b[i] -= left",
"- right = min(a[i + 1], b[i])",
"- ans += right",
"- a[i + 1] -= right",
"- b[i] -= right",
"-print(ans)",
"+import sys",
"+",
"+sys.setrecursionlimit(10**7)",
"+f_inf = float(\"inf\")",
"+mod = 10**9 + 7",
"+",
"+",
"+def resolve():",
"+ n = int(eval(input()))",
"+ A = list(map(int, input().split()))",
"+ B = list(map(int, input().split()))",
"+ res = 0",
"+ for i in range(n):",
"+ if A[i] <= B[i]:",
"+ res += A[i]",
"+ B[i] -= A[i]",
"+ A[i] = 0",
"+ if A[i + 1] <= B[i]:",
"+ res += A[i + 1]",
"+ B[i] -= A[i + 1]",
"+ A[i + 1] = 0",
"+ else:",
"+ res += B[i]",
"+ A[i + 1] -= B[i]",
"+ B[i] = 0",
"+ else:",
"+ res += B[i]",
"+ A[i] -= B[i]",
"+ B[i] = 0",
"+ print(res)",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ resolve()"
] | false
| 0.043277
| 0.042861
| 1.009702
|
[
"s223298972",
"s335895939"
] |
u493520238
|
p03291
|
python
|
s660417706
|
s691924525
| 146
| 113
| 74,288
| 73,612
|
Accepted
|
Accepted
| 22.6
|
def modinv(a,m):
b, u, v = m, 1, 0
while b:
t = a//b
a -= t*b
a,b = b,a
u -= t * v
u,v = v,u
u %= m
return u
s=eval(input())
all_hatena = s.count('?')
a_cnt = 0
ab_cnt = 0
hatena_cnt = 0
ans = 0
MOD = 10**9+7
for si in s:
if si == 'A':
a_cnt += 1
elif si == 'B':
ab_cnt += a_cnt*pow(3,all_hatena,MOD)
if all_hatena >= 1: ab_cnt += hatena_cnt*pow(3,all_hatena-1,MOD)
elif si == 'C':
ans += ab_cnt
else:
ans += ab_cnt*modinv(3,MOD)
ab_cnt += a_cnt*pow(3,all_hatena-1,MOD)
if all_hatena >= 2: ab_cnt += hatena_cnt*pow(3,all_hatena-2,MOD)
hatena_cnt += 1
ab_cnt%=MOD
ans%=MOD
print(ans)
|
s=eval(input())
all_hatena = s.count('?')
a_cnt = 0
ab_cnt = 0
hatena_cnt = 0
ans = 0
MOD = 10**9+7
for si in s:
if si == 'A':
a_cnt += 1
elif si == 'B':
ab_cnt += a_cnt*pow(3,all_hatena,MOD)
if all_hatena >= 1: ab_cnt += hatena_cnt*pow(3,all_hatena-1,MOD)
elif si == 'C':
ans += ab_cnt
else:
ans += ab_cnt*333333336 # modinv(3,MOD)
ab_cnt += a_cnt*pow(3,all_hatena-1,MOD)
if all_hatena >= 2: ab_cnt += hatena_cnt*pow(3,all_hatena-2,MOD)
hatena_cnt += 1
ab_cnt%=MOD
ans%=MOD
print(ans)
| 36
| 25
| 758
| 593
|
def modinv(a, m):
b, u, v = m, 1, 0
while b:
t = a // b
a -= t * b
a, b = b, a
u -= t * v
u, v = v, u
u %= m
return u
s = eval(input())
all_hatena = s.count("?")
a_cnt = 0
ab_cnt = 0
hatena_cnt = 0
ans = 0
MOD = 10**9 + 7
for si in s:
if si == "A":
a_cnt += 1
elif si == "B":
ab_cnt += a_cnt * pow(3, all_hatena, MOD)
if all_hatena >= 1:
ab_cnt += hatena_cnt * pow(3, all_hatena - 1, MOD)
elif si == "C":
ans += ab_cnt
else:
ans += ab_cnt * modinv(3, MOD)
ab_cnt += a_cnt * pow(3, all_hatena - 1, MOD)
if all_hatena >= 2:
ab_cnt += hatena_cnt * pow(3, all_hatena - 2, MOD)
hatena_cnt += 1
ab_cnt %= MOD
ans %= MOD
print(ans)
|
s = eval(input())
all_hatena = s.count("?")
a_cnt = 0
ab_cnt = 0
hatena_cnt = 0
ans = 0
MOD = 10**9 + 7
for si in s:
if si == "A":
a_cnt += 1
elif si == "B":
ab_cnt += a_cnt * pow(3, all_hatena, MOD)
if all_hatena >= 1:
ab_cnt += hatena_cnt * pow(3, all_hatena - 1, MOD)
elif si == "C":
ans += ab_cnt
else:
ans += ab_cnt * 333333336 # modinv(3,MOD)
ab_cnt += a_cnt * pow(3, all_hatena - 1, MOD)
if all_hatena >= 2:
ab_cnt += hatena_cnt * pow(3, all_hatena - 2, MOD)
hatena_cnt += 1
ab_cnt %= MOD
ans %= MOD
print(ans)
| false
| 30.555556
|
[
"-def modinv(a, m):",
"- b, u, v = m, 1, 0",
"- while b:",
"- t = a // b",
"- a -= t * b",
"- a, b = b, a",
"- u -= t * v",
"- u, v = v, u",
"- u %= m",
"- return u",
"-",
"-",
"- ans += ab_cnt * modinv(3, MOD)",
"+ ans += ab_cnt * 333333336 # modinv(3,MOD)"
] | false
| 0.044079
| 0.04722
| 0.933474
|
[
"s660417706",
"s691924525"
] |
u197968862
|
p02881
|
python
|
s017281464
|
s403225922
| 339
| 312
| 3,060
| 3,552
|
Accepted
|
Accepted
| 7.96
|
n = int(eval(input()))
i = 1
ans = 10**13
while(i*i<=n):
if n%i == 0:
ans = min(ans,n//i+i-2)
i+=1
print(ans)
|
n = int(eval(input()))
i = 1
ele = []
while i * i <= n:
if n % i == 0:
ele.append([i,n//i])
i += 1
ans = 10**13
for i in range(len(ele)):
ans = min(ans,ele[i][0]+ele[i][1]-2)
print(ans)
| 8
| 13
| 126
| 213
|
n = int(eval(input()))
i = 1
ans = 10**13
while i * i <= n:
if n % i == 0:
ans = min(ans, n // i + i - 2)
i += 1
print(ans)
|
n = int(eval(input()))
i = 1
ele = []
while i * i <= n:
if n % i == 0:
ele.append([i, n // i])
i += 1
ans = 10**13
for i in range(len(ele)):
ans = min(ans, ele[i][0] + ele[i][1] - 2)
print(ans)
| false
| 38.461538
|
[
"-ans = 10**13",
"+ele = []",
"- ans = min(ans, n // i + i - 2)",
"+ ele.append([i, n // i])",
"+ans = 10**13",
"+for i in range(len(ele)):",
"+ ans = min(ans, ele[i][0] + ele[i][1] - 2)"
] | false
| 0.055026
| 0.162126
| 0.339402
|
[
"s017281464",
"s403225922"
] |
u197955752
|
p03283
|
python
|
s958309733
|
s304365610
| 1,101
| 631
| 25,872
| 25,872
|
Accepted
|
Accepted
| 42.69
|
N, M, Q = [int(x) for x in input().split()]
L = [0] * M
R = [0] * M
p = [0] * Q
q = [0] * Q
for i in range(M):
L[i], R[i] = [int(x) for x in input().split()]
for j in range(Q):
p[j], q[j] = [int(x) for x in input().split()]
train = [[0 for i in range(N + 1)] for _ in range(N + 1)]
seg = [[0 for i in range(N + 1)] for _ in range(N + 2)]
for i in range(M): # すべての列車について
train[L[i]][R[i]] += 1
for col in range(1, N + 1):
for row in range(col, 0, -1):
seg[row][col] = train[row][col] + seg[row][col - 1] + seg[row + 1][col] - seg[row + 1][col - 1]
for j in range(Q):
print((seg[p[j]][q[j]]))
|
import sys
input = sys.stdin.readline
N, M, Q = [int(x) for x in input().split()]
L = [0] * M
R = [0] * M
p = [0] * Q
q = [0] * Q
for i in range(M):
L[i], R[i] = [int(x) for x in input().split()]
for j in range(Q):
p[j], q[j] = [int(x) for x in input().split()]
train = [[0 for i in range(N + 1)] for _ in range(N + 1)]
seg = [[0 for i in range(N + 1)] for _ in range(N + 2)]
for i in range(M): # すべての列車について
train[L[i]][R[i]] += 1
for col in range(1, N + 1):
for row in range(col, 0, -1):
seg[row][col] = train[row][col] + seg[row][col - 1] + seg[row + 1][col] - seg[row + 1][col - 1]
for j in range(Q):
print((seg[p[j]][q[j]]))
| 22
| 25
| 642
| 684
|
N, M, Q = [int(x) for x in input().split()]
L = [0] * M
R = [0] * M
p = [0] * Q
q = [0] * Q
for i in range(M):
L[i], R[i] = [int(x) for x in input().split()]
for j in range(Q):
p[j], q[j] = [int(x) for x in input().split()]
train = [[0 for i in range(N + 1)] for _ in range(N + 1)]
seg = [[0 for i in range(N + 1)] for _ in range(N + 2)]
for i in range(M): # すべての列車について
train[L[i]][R[i]] += 1
for col in range(1, N + 1):
for row in range(col, 0, -1):
seg[row][col] = (
train[row][col]
+ seg[row][col - 1]
+ seg[row + 1][col]
- seg[row + 1][col - 1]
)
for j in range(Q):
print((seg[p[j]][q[j]]))
|
import sys
input = sys.stdin.readline
N, M, Q = [int(x) for x in input().split()]
L = [0] * M
R = [0] * M
p = [0] * Q
q = [0] * Q
for i in range(M):
L[i], R[i] = [int(x) for x in input().split()]
for j in range(Q):
p[j], q[j] = [int(x) for x in input().split()]
train = [[0 for i in range(N + 1)] for _ in range(N + 1)]
seg = [[0 for i in range(N + 1)] for _ in range(N + 2)]
for i in range(M): # すべての列車について
train[L[i]][R[i]] += 1
for col in range(1, N + 1):
for row in range(col, 0, -1):
seg[row][col] = (
train[row][col]
+ seg[row][col - 1]
+ seg[row + 1][col]
- seg[row + 1][col - 1]
)
for j in range(Q):
print((seg[p[j]][q[j]]))
| false
| 12
|
[
"+import sys",
"+",
"+input = sys.stdin.readline"
] | false
| 0.037821
| 0.041463
| 0.912168
|
[
"s958309733",
"s304365610"
] |
u223646582
|
p03283
|
python
|
s097545225
|
s358149758
| 2,913
| 1,732
| 56,612
| 59,608
|
Accepted
|
Accepted
| 40.54
|
N, M, Q = list(map(int, input().split()))
X = [[0 for j in range(510)] for i in range(510)]
C = [[0 for j in range(510)] for i in range(510)]
LR = []
for i in range(M):
L, R = list(map(int, input().split()))
X[L][R] += 1
for i in range(1, N+1):
for j in range(1, N+1):
C[i][j] = C[i][j-1]+X[i][j]
for i in range(Q):
p, q = list(map(int, input().split()))
sum = 0
for j in range(p, q+1):
sum += C[j][q]-C[j][p-1]
print(sum)
|
N, M, Q = list(map(int, input().split()))
# 入力
A = [[0 for j in range(N+1)] for i in range(N+1)]
for _ in range(M):
L, R = list(map(int, input().split()))
A[L][R] += 1
# 二次元累積和
Cum = [[0 for j in range(N+1)] for i in range(N+1)]
for i in range(N):
for j in range(N):
Cum[i+1][j+1] = Cum[i][j+1] + Cum[i+1][j] - Cum[i][j] + A[i+1][j+1]
# クエリ処理
for _ in range(Q):
p, q = list(map(int, input().split()))
print((Cum[q][q]-Cum[p-1][q]-Cum[q][p-1]+Cum[p-1][p-1]))
| 21
| 19
| 474
| 488
|
N, M, Q = list(map(int, input().split()))
X = [[0 for j in range(510)] for i in range(510)]
C = [[0 for j in range(510)] for i in range(510)]
LR = []
for i in range(M):
L, R = list(map(int, input().split()))
X[L][R] += 1
for i in range(1, N + 1):
for j in range(1, N + 1):
C[i][j] = C[i][j - 1] + X[i][j]
for i in range(Q):
p, q = list(map(int, input().split()))
sum = 0
for j in range(p, q + 1):
sum += C[j][q] - C[j][p - 1]
print(sum)
|
N, M, Q = list(map(int, input().split()))
# 入力
A = [[0 for j in range(N + 1)] for i in range(N + 1)]
for _ in range(M):
L, R = list(map(int, input().split()))
A[L][R] += 1
# 二次元累積和
Cum = [[0 for j in range(N + 1)] for i in range(N + 1)]
for i in range(N):
for j in range(N):
Cum[i + 1][j + 1] = Cum[i][j + 1] + Cum[i + 1][j] - Cum[i][j] + A[i + 1][j + 1]
# クエリ処理
for _ in range(Q):
p, q = list(map(int, input().split()))
print((Cum[q][q] - Cum[p - 1][q] - Cum[q][p - 1] + Cum[p - 1][p - 1]))
| false
| 9.52381
|
[
"-X = [[0 for j in range(510)] for i in range(510)]",
"-C = [[0 for j in range(510)] for i in range(510)]",
"-LR = []",
"-for i in range(M):",
"+# 入力",
"+A = [[0 for j in range(N + 1)] for i in range(N + 1)]",
"+for _ in range(M):",
"- X[L][R] += 1",
"-for i in range(1, N + 1):",
"- for j in range(1, N + 1):",
"- C[i][j] = C[i][j - 1] + X[i][j]",
"-for i in range(Q):",
"+ A[L][R] += 1",
"+# 二次元累積和",
"+Cum = [[0 for j in range(N + 1)] for i in range(N + 1)]",
"+for i in range(N):",
"+ for j in range(N):",
"+ Cum[i + 1][j + 1] = Cum[i][j + 1] + Cum[i + 1][j] - Cum[i][j] + A[i + 1][j + 1]",
"+# クエリ処理",
"+for _ in range(Q):",
"- sum = 0",
"- for j in range(p, q + 1):",
"- sum += C[j][q] - C[j][p - 1]",
"- print(sum)",
"+ print((Cum[q][q] - Cum[p - 1][q] - Cum[q][p - 1] + Cum[p - 1][p - 1]))"
] | false
| 0.160922
| 0.060828
| 2.645511
|
[
"s097545225",
"s358149758"
] |
u204208382
|
p02707
|
python
|
s277231955
|
s449161522
| 207
| 156
| 92,404
| 92,216
|
Accepted
|
Accepted
| 24.64
|
import collections
n = int(eval(input()))
a = list(map(int, input().split()))
a.sort()
a = collections.deque(a)
counter = 0
for i in range(1, n+1):
while len(a) != 0:
if i != a[0]:
break
counter += 1
a.popleft()
print(counter)
counter = 0
|
n = int(eval(input()))
a = list(map(int, input().split()))
ans = [0]*n
counter = 0
for i in range(n-1):
ans[a[i]-1] += 1
for i in range(n):
print((ans[i]))
| 16
| 12
| 307
| 175
|
import collections
n = int(eval(input()))
a = list(map(int, input().split()))
a.sort()
a = collections.deque(a)
counter = 0
for i in range(1, n + 1):
while len(a) != 0:
if i != a[0]:
break
counter += 1
a.popleft()
print(counter)
counter = 0
|
n = int(eval(input()))
a = list(map(int, input().split()))
ans = [0] * n
counter = 0
for i in range(n - 1):
ans[a[i] - 1] += 1
for i in range(n):
print((ans[i]))
| false
| 25
|
[
"-import collections",
"-",
"-a.sort()",
"-a = collections.deque(a)",
"+ans = [0] * n",
"-for i in range(1, n + 1):",
"- while len(a) != 0:",
"- if i != a[0]:",
"- break",
"- counter += 1",
"- a.popleft()",
"- print(counter)",
"- counter = 0",
"+for i in range(n - 1):",
"+ ans[a[i] - 1] += 1",
"+for i in range(n):",
"+ print((ans[i]))"
] | false
| 0.100376
| 0.033864
| 2.964068
|
[
"s277231955",
"s449161522"
] |
u130900604
|
p02678
|
python
|
s480041007
|
s486882513
| 494
| 451
| 97,160
| 101,436
|
Accepted
|
Accepted
| 8.7
|
def LI():return list(map(int,input().split()))
def yes():print("Yes")
def no():print("No")
from collections import deque
def main():
n,m=LI()
edge=[[] for i in range(n)]
for i in range(m):
a,b=LI()
a-=1;b-=1
edge[a].append(b)
edge[b].append(a)
ans=[-1]*(n)
goal=deque([0])
while goal:
g=goal.popleft()
for i in edge[g]:
if ans[i]==-1:
ans[i]=g+1
goal.append(i)
yes()
print((*ans[1:]))
main()
|
def LI():return list(map(int,input().split()))
def yes():print("Yes")
def no():print("No")
from collections import deque
def main():
n,m=LI()
edge=[[]*n for i in range(n)]
for i in range(m):
a,b=LI()
a-=1;b-=1
edge[a].append(b)
edge[b].append(a)
ans=[-1]*(n)
goal=deque([0])
while goal:
g=goal.popleft()
for i in edge[g]:
if ans[i]==-1:
ans[i]=g+1
goal.append(i)
yes()
print((*ans[1:]))
main()
| 25
| 26
| 548
| 552
|
def LI():
return list(map(int, input().split()))
def yes():
print("Yes")
def no():
print("No")
from collections import deque
def main():
n, m = LI()
edge = [[] for i in range(n)]
for i in range(m):
a, b = LI()
a -= 1
b -= 1
edge[a].append(b)
edge[b].append(a)
ans = [-1] * (n)
goal = deque([0])
while goal:
g = goal.popleft()
for i in edge[g]:
if ans[i] == -1:
ans[i] = g + 1
goal.append(i)
yes()
print((*ans[1:]))
main()
|
def LI():
return list(map(int, input().split()))
def yes():
print("Yes")
def no():
print("No")
from collections import deque
def main():
n, m = LI()
edge = [[] * n for i in range(n)]
for i in range(m):
a, b = LI()
a -= 1
b -= 1
edge[a].append(b)
edge[b].append(a)
ans = [-1] * (n)
goal = deque([0])
while goal:
g = goal.popleft()
for i in edge[g]:
if ans[i] == -1:
ans[i] = g + 1
goal.append(i)
yes()
print((*ans[1:]))
main()
| false
| 3.846154
|
[
"- edge = [[] for i in range(n)]",
"+ edge = [[] * n for i in range(n)]"
] | false
| 0.106622
| 0.079371
| 1.34334
|
[
"s480041007",
"s486882513"
] |
u124498235
|
p03611
|
python
|
s148650025
|
s560515804
| 200
| 146
| 33,752
| 14,564
|
Accepted
|
Accepted
| 27
|
from collections import Counter
n = int(eval(input()))
a = list(map(int, input().split()))
b = [i+1 for i in a]
c = [i-1 for i in a]
d = dict(Counter(a) + Counter(b) + Counter(c))
print((max(d.values())))
|
from collections import Counter
n = int(eval(input()))
a = list(map(int, input().split()))
c = Counter(a)
d = list(c.keys())
q = 1
for i in range(1,len(d)-1):
if d[i+1] - d[i] == 1 and d[i] - d[i-1] == 1:
s = c[d[i-1]] + c[d[i]] + c[d[i+1]]
q = max(q,s)
if i == 1:
if d[i] - d[i-1] == 1:
s = c[d[i-1]] + c[d[i]]
q = max(q, s)
if d[i+1] - d[i] == 1:
s = c[d[i+1]] - c[d[i]]
q = max(q, s)
if len(d) == 1:
q = c[d[0]]
if len(d) == 2:
if d[1] - d[0] == 1:
q = c[d[1]] + c[d[0]]
else:
q = max(1, c[d[1]], c[d[0]])
print (q)
| 8
| 25
| 205
| 562
|
from collections import Counter
n = int(eval(input()))
a = list(map(int, input().split()))
b = [i + 1 for i in a]
c = [i - 1 for i in a]
d = dict(Counter(a) + Counter(b) + Counter(c))
print((max(d.values())))
|
from collections import Counter
n = int(eval(input()))
a = list(map(int, input().split()))
c = Counter(a)
d = list(c.keys())
q = 1
for i in range(1, len(d) - 1):
if d[i + 1] - d[i] == 1 and d[i] - d[i - 1] == 1:
s = c[d[i - 1]] + c[d[i]] + c[d[i + 1]]
q = max(q, s)
if i == 1:
if d[i] - d[i - 1] == 1:
s = c[d[i - 1]] + c[d[i]]
q = max(q, s)
if d[i + 1] - d[i] == 1:
s = c[d[i + 1]] - c[d[i]]
q = max(q, s)
if len(d) == 1:
q = c[d[0]]
if len(d) == 2:
if d[1] - d[0] == 1:
q = c[d[1]] + c[d[0]]
else:
q = max(1, c[d[1]], c[d[0]])
print(q)
| false
| 68
|
[
"-b = [i + 1 for i in a]",
"-c = [i - 1 for i in a]",
"-d = dict(Counter(a) + Counter(b) + Counter(c))",
"-print((max(d.values())))",
"+c = Counter(a)",
"+d = list(c.keys())",
"+q = 1",
"+for i in range(1, len(d) - 1):",
"+ if d[i + 1] - d[i] == 1 and d[i] - d[i - 1] == 1:",
"+ s = c[d[i - 1]] + c[d[i]] + c[d[i + 1]]",
"+ q = max(q, s)",
"+ if i == 1:",
"+ if d[i] - d[i - 1] == 1:",
"+ s = c[d[i - 1]] + c[d[i]]",
"+ q = max(q, s)",
"+ if d[i + 1] - d[i] == 1:",
"+ s = c[d[i + 1]] - c[d[i]]",
"+ q = max(q, s)",
"+if len(d) == 1:",
"+ q = c[d[0]]",
"+if len(d) == 2:",
"+ if d[1] - d[0] == 1:",
"+ q = c[d[1]] + c[d[0]]",
"+ else:",
"+ q = max(1, c[d[1]], c[d[0]])",
"+print(q)"
] | false
| 0.038128
| 0.040878
| 0.932724
|
[
"s148650025",
"s560515804"
] |
u079022693
|
p02647
|
python
|
s973201327
|
s660896239
| 811
| 729
| 123,072
| 129,068
|
Accepted
|
Accepted
| 10.11
|
from sys import stdin
import numpy as np
from numba import njit
def main():
#入力
readline=stdin.readline
n,k=list(map(int,readline().split()))
a=np.array(list(map(int,readline().split())),dtype=np.int64)
cnt=0
while cnt<k:
s=f(n,a)
a=np.cumsum(s)
cnt+=1
if a[a==n].size==n:
break
print((*a))
@njit(cache=True)
def f(n,a):
s=np.zeros(n,dtype=np.int64)
for i in range(n):
x_min=i-a[i]
x_max=i+a[i]+1
s[max(0,x_min)]+=1
if n-1<x_max:
pass
else:
s[x_max]-=1
return s
if __name__=="__main__":
main()
|
from sys import stdin
import numpy as np
from numba import njit
def main():
#入力
readline=stdin.readline
n,k=list(map(int,readline().split()))
a=np.array(list(map(int,readline().split())),dtype=np.int64)
cnt=0
while cnt<k:
s=f(n,a)
a=np.cumsum(s)
cnt+=1
if a[a==n].size==n:
break
print((*a))
@njit("i8[:](i8,i8[:])",cache=True)
def f(n,a):
s=np.zeros(n,dtype=np.int64)
for i in range(n):
x_min=i-a[i]
x_max=i+a[i]+1
s[max(0,x_min)]+=1
if n-1<x_max:
pass
else:
s[x_max]-=1
return s
if __name__=="__main__":
main()
| 34
| 34
| 674
| 692
|
from sys import stdin
import numpy as np
from numba import njit
def main():
# 入力
readline = stdin.readline
n, k = list(map(int, readline().split()))
a = np.array(list(map(int, readline().split())), dtype=np.int64)
cnt = 0
while cnt < k:
s = f(n, a)
a = np.cumsum(s)
cnt += 1
if a[a == n].size == n:
break
print((*a))
@njit(cache=True)
def f(n, a):
s = np.zeros(n, dtype=np.int64)
for i in range(n):
x_min = i - a[i]
x_max = i + a[i] + 1
s[max(0, x_min)] += 1
if n - 1 < x_max:
pass
else:
s[x_max] -= 1
return s
if __name__ == "__main__":
main()
|
from sys import stdin
import numpy as np
from numba import njit
def main():
# 入力
readline = stdin.readline
n, k = list(map(int, readline().split()))
a = np.array(list(map(int, readline().split())), dtype=np.int64)
cnt = 0
while cnt < k:
s = f(n, a)
a = np.cumsum(s)
cnt += 1
if a[a == n].size == n:
break
print((*a))
@njit("i8[:](i8,i8[:])", cache=True)
def f(n, a):
s = np.zeros(n, dtype=np.int64)
for i in range(n):
x_min = i - a[i]
x_max = i + a[i] + 1
s[max(0, x_min)] += 1
if n - 1 < x_max:
pass
else:
s[x_max] -= 1
return s
if __name__ == "__main__":
main()
| false
| 0
|
[
"-@njit(cache=True)",
"+@njit(\"i8[:](i8,i8[:])\", cache=True)"
] | false
| 0.206714
| 0.540157
| 0.382692
|
[
"s973201327",
"s660896239"
] |
u714878632
|
p02897
|
python
|
s606102602
|
s456398092
| 412
| 17
| 21,504
| 2,940
|
Accepted
|
Accepted
| 95.87
|
from sys import stdin
import numpy as np
# noinspection PyShadowingBuiltinsInspection
def main():
n = int(eval(input()))
if n % 2 == 0:
print((0.5))
else:
m = (n + 1) / 2
print((m / n))
return
if __name__ == "__main__":
main()
|
N = int(eval(input()))
if N % 2 == 0:
ret = 0.5
else:
ret = (N/2 + 0.5)/(N)
print(ret)
| 18
| 7
| 282
| 91
|
from sys import stdin
import numpy as np
# noinspection PyShadowingBuiltinsInspection
def main():
n = int(eval(input()))
if n % 2 == 0:
print((0.5))
else:
m = (n + 1) / 2
print((m / n))
return
if __name__ == "__main__":
main()
|
N = int(eval(input()))
if N % 2 == 0:
ret = 0.5
else:
ret = (N / 2 + 0.5) / (N)
print(ret)
| false
| 61.111111
|
[
"-from sys import stdin",
"-import numpy as np",
"-",
"-# noinspection PyShadowingBuiltinsInspection",
"-def main():",
"- n = int(eval(input()))",
"- if n % 2 == 0:",
"- print((0.5))",
"- else:",
"- m = (n + 1) / 2",
"- print((m / n))",
"- return",
"-",
"-",
"-if __name__ == \"__main__\":",
"- main()",
"+N = int(eval(input()))",
"+if N % 2 == 0:",
"+ ret = 0.5",
"+else:",
"+ ret = (N / 2 + 0.5) / (N)",
"+print(ret)"
] | false
| 0.044599
| 0.037261
| 1.196933
|
[
"s606102602",
"s456398092"
] |
u133936772
|
p02572
|
python
|
s544933836
|
s814737831
| 133
| 119
| 31,424
| 31,732
|
Accepted
|
Accepted
| 10.53
|
M=10**9+7
n=int(eval(input()))
l=[*list(map(int,input().split()))]
print(((sum(i for i in l)**2-sum(i**2 for i in l))//2%M))
|
n,*l=list(map(int,open(0).read().split()))
print(((sum(l)**2-sum(i**2 for i in l))//2%(10**9+7)))
| 4
| 2
| 113
| 90
|
M = 10**9 + 7
n = int(eval(input()))
l = [*list(map(int, input().split()))]
print(((sum(i for i in l) ** 2 - sum(i**2 for i in l)) // 2 % M))
|
n, *l = list(map(int, open(0).read().split()))
print(((sum(l) ** 2 - sum(i**2 for i in l)) // 2 % (10**9 + 7)))
| false
| 50
|
[
"-M = 10**9 + 7",
"-n = int(eval(input()))",
"-l = [*list(map(int, input().split()))]",
"-print(((sum(i for i in l) ** 2 - sum(i**2 for i in l)) // 2 % M))",
"+n, *l = list(map(int, open(0).read().split()))",
"+print(((sum(l) ** 2 - sum(i**2 for i in l)) // 2 % (10**9 + 7)))"
] | false
| 0.075425
| 0.072947
| 1.033971
|
[
"s544933836",
"s814737831"
] |
u945181840
|
p03583
|
python
|
s240695286
|
s550412193
| 1,843
| 20
| 3,060
| 3,060
|
Accepted
|
Accepted
| 98.91
|
N = int(eval(input()))
for h in range(1, 3501):
for n in range(1, 3501):
mod = 4 * h * n - N * (h + n)
if mod > 0:
w, r = divmod(N * h * n, mod)
if r == 0:
print((h, n, w))
exit()
|
N = int(eval(input()))
for h in range(N // 4, 3501):
for n in range(N * h // max(1, (4 * h - N)), 3501):
mod = 4 * h * n - N * (h + n)
if mod > 0:
w, r = divmod(N * h * n, mod)
if r == 0:
print((h, n, w))
exit()
| 9
| 9
| 255
| 287
|
N = int(eval(input()))
for h in range(1, 3501):
for n in range(1, 3501):
mod = 4 * h * n - N * (h + n)
if mod > 0:
w, r = divmod(N * h * n, mod)
if r == 0:
print((h, n, w))
exit()
|
N = int(eval(input()))
for h in range(N // 4, 3501):
for n in range(N * h // max(1, (4 * h - N)), 3501):
mod = 4 * h * n - N * (h + n)
if mod > 0:
w, r = divmod(N * h * n, mod)
if r == 0:
print((h, n, w))
exit()
| false
| 0
|
[
"-for h in range(1, 3501):",
"- for n in range(1, 3501):",
"+for h in range(N // 4, 3501):",
"+ for n in range(N * h // max(1, (4 * h - N)), 3501):"
] | false
| 1.641363
| 0.053901
| 30.451205
|
[
"s240695286",
"s550412193"
] |
u852690916
|
p03352
|
python
|
s994064995
|
s551698646
| 166
| 19
| 38,384
| 3,188
|
Accepted
|
Accepted
| 88.55
|
X=int(eval(input()))
ans=1
for i in range(2,int(X**0.5)+1):
j = 1
n = i
while n*i <= X:
n *= i
j += 1
ans = max(ans, n)
print(ans)
|
X=int(eval(input()))
ans=1
for i in range(1,1000):
for j in range(2,1000):
t=i**j
if t>X: break
ans = max(ans, t)
print(ans)
| 12
| 8
| 169
| 153
|
X = int(eval(input()))
ans = 1
for i in range(2, int(X**0.5) + 1):
j = 1
n = i
while n * i <= X:
n *= i
j += 1
ans = max(ans, n)
print(ans)
|
X = int(eval(input()))
ans = 1
for i in range(1, 1000):
for j in range(2, 1000):
t = i**j
if t > X:
break
ans = max(ans, t)
print(ans)
| false
| 33.333333
|
[
"-for i in range(2, int(X**0.5) + 1):",
"- j = 1",
"- n = i",
"- while n * i <= X:",
"- n *= i",
"- j += 1",
"- ans = max(ans, n)",
"+for i in range(1, 1000):",
"+ for j in range(2, 1000):",
"+ t = i**j",
"+ if t > X:",
"+ break",
"+ ans = max(ans, t)"
] | false
| 0.0459
| 0.047044
| 0.975696
|
[
"s994064995",
"s551698646"
] |
u691018832
|
p03673
|
python
|
s173825982
|
s051952139
| 357
| 214
| 25,160
| 23,656
|
Accepted
|
Accepted
| 40.06
|
import math
import sys
input = sys.stdin.readline
n = int(input())
a = list(map(int, input().split()))
be = []
af = []
for i in range(math.floor(n/2)):
be.append(a[n-(2*i)-1])
af.append(a[n-(2*i)-2])
af.reverse()
if n%2 == 1:
ans = be + [a[0]] + af
else:
ans = be + af
for i in range(n):
print(ans[i], end=' ')
print('\n')
|
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
from collections import deque
n, *a = list(map(int, read().split()))
b = deque()
v = 1 if n % 2 == 0 else 0
for i, aa in enumerate(a):
if i % 2 == v:
b.appendleft(aa)
else:
b.append(aa)
print((*b))
| 19
| 17
| 361
| 379
|
import math
import sys
input = sys.stdin.readline
n = int(input())
a = list(map(int, input().split()))
be = []
af = []
for i in range(math.floor(n / 2)):
be.append(a[n - (2 * i) - 1])
af.append(a[n - (2 * i) - 2])
af.reverse()
if n % 2 == 1:
ans = be + [a[0]] + af
else:
ans = be + af
for i in range(n):
print(ans[i], end=" ")
print("\n")
|
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10**7)
from collections import deque
n, *a = list(map(int, read().split()))
b = deque()
v = 1 if n % 2 == 0 else 0
for i, aa in enumerate(a):
if i % 2 == v:
b.appendleft(aa)
else:
b.append(aa)
print((*b))
| false
| 10.526316
|
[
"-import math",
"-input = sys.stdin.readline",
"-n = int(input())",
"-a = list(map(int, input().split()))",
"-be = []",
"-af = []",
"-for i in range(math.floor(n / 2)):",
"- be.append(a[n - (2 * i) - 1])",
"- af.append(a[n - (2 * i) - 2])",
"-af.reverse()",
"-if n % 2 == 1:",
"- ans = be + [a[0]] + af",
"-else:",
"- ans = be + af",
"-for i in range(n):",
"- print(ans[i], end=\" \")",
"-print(\"\\n\")",
"+read = sys.stdin.buffer.read",
"+readline = sys.stdin.buffer.readline",
"+readlines = sys.stdin.buffer.readlines",
"+sys.setrecursionlimit(10**7)",
"+from collections import deque",
"+",
"+n, *a = list(map(int, read().split()))",
"+b = deque()",
"+v = 1 if n % 2 == 0 else 0",
"+for i, aa in enumerate(a):",
"+ if i % 2 == v:",
"+ b.appendleft(aa)",
"+ else:",
"+ b.append(aa)",
"+print((*b))"
] | false
| 0.039979
| 0.133572
| 0.299303
|
[
"s173825982",
"s051952139"
] |
u986399983
|
p03951
|
python
|
s147077160
|
s709455366
| 19
| 12
| 3,956
| 3,588
|
Accepted
|
Accepted
| 36.84
|
i=input;N=int(i());s=i();l=i();n=N;j=0
exec("j=max(n*(s[-n:]==l[:n]),j);n-=1;"*N);print((2*N-j))
|
i=raw_input;N=n=int(i());s,l,j=i(),i(),0;
exec("j=max(n*(s[-n:]==l[:n]),j);n-=1;"*N);
print(2*N-j)
| 2
| 3
| 95
| 98
|
i = input
N = int(i())
s = i()
l = i()
n = N
j = 0
exec("j=max(n*(s[-n:]==l[:n]),j);n-=1;" * N)
print((2 * N - j))
|
i = raw_input
N = n = int(i())
s, l, j = i(), i(), 0
exec("j=max(n*(s[-n:]==l[:n]),j);n-=1;" * N)
print(2 * N - j)
| false
| 33.333333
|
[
"-i = input",
"-N = int(i())",
"-s = i()",
"-l = i()",
"-n = N",
"-j = 0",
"+i = raw_input",
"+N = n = int(i())",
"+s, l, j = i(), i(), 0",
"-print((2 * N - j))",
"+print(2 * N - j)"
] | false
| 0.03502
| 0.042408
| 0.825794
|
[
"s147077160",
"s709455366"
] |
u162911959
|
p02837
|
python
|
s584968879
|
s286274411
| 668
| 235
| 3,064
| 3,064
|
Accepted
|
Accepted
| 64.82
|
#!/usr/bin/env python3
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 7)
N = int(readline())
tes = [[-1]*N for i in range(N)]
for i in range(N):
A = int(readline())
for j in range(A):
x,y = list(map(int,readline().rstrip().split()))
tes[i][x-1] = y
cnt = 0
for i in range(2**N):
hon = [0]*N
for j in range(N):
if (i>>j)&1:
hon[j] = 1
flag = True
for j in range(N):
if not flag:
break
if hon[j]:
for k in range(N):
if tes[j][k] == -1:
continue
if tes[j][k] != hon[k]:
flag = False
break
if flag:
cnt = max(cnt,hon.count(1))
print(cnt)
|
#!/usr/bin/env python3
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 7)
N = int(readline())
tes = [[] for i in range(N)]
for i in range(N):
A = int(readline())
for j in range(A):
x,y = list(map(int,readline().rstrip().split()))
tes[i].append((x-1,y))
cnt = 0
for i in range(2**N):
flag = True
for j in range(N):
if (i>>j)&1 == 1:
for x,y in tes[j]:
if (i>>x)&1 != y:
flag = False
break
if flag:
cnt = max(cnt,bin(i)[2:].count("1"))
print(cnt)
| 36
| 27
| 857
| 661
|
#!/usr/bin/env python3
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10**7)
N = int(readline())
tes = [[-1] * N for i in range(N)]
for i in range(N):
A = int(readline())
for j in range(A):
x, y = list(map(int, readline().rstrip().split()))
tes[i][x - 1] = y
cnt = 0
for i in range(2**N):
hon = [0] * N
for j in range(N):
if (i >> j) & 1:
hon[j] = 1
flag = True
for j in range(N):
if not flag:
break
if hon[j]:
for k in range(N):
if tes[j][k] == -1:
continue
if tes[j][k] != hon[k]:
flag = False
break
if flag:
cnt = max(cnt, hon.count(1))
print(cnt)
|
#!/usr/bin/env python3
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10**7)
N = int(readline())
tes = [[] for i in range(N)]
for i in range(N):
A = int(readline())
for j in range(A):
x, y = list(map(int, readline().rstrip().split()))
tes[i].append((x - 1, y))
cnt = 0
for i in range(2**N):
flag = True
for j in range(N):
if (i >> j) & 1 == 1:
for x, y in tes[j]:
if (i >> x) & 1 != y:
flag = False
break
if flag:
cnt = max(cnt, bin(i)[2:].count("1"))
print(cnt)
| false
| 25
|
[
"-tes = [[-1] * N for i in range(N)]",
"+tes = [[] for i in range(N)]",
"- tes[i][x - 1] = y",
"+ tes[i].append((x - 1, y))",
"- hon = [0] * N",
"- for j in range(N):",
"- if (i >> j) & 1:",
"- hon[j] = 1",
"- if not flag:",
"- break",
"- if hon[j]:",
"- for k in range(N):",
"- if tes[j][k] == -1:",
"- continue",
"- if tes[j][k] != hon[k]:",
"+ if (i >> j) & 1 == 1:",
"+ for x, y in tes[j]:",
"+ if (i >> x) & 1 != y:",
"- cnt = max(cnt, hon.count(1))",
"+ cnt = max(cnt, bin(i)[2:].count(\"1\"))"
] | false
| 0.036814
| 0.066225
| 0.555894
|
[
"s584968879",
"s286274411"
] |
u218834617
|
p02762
|
python
|
s250997492
|
s732442872
| 398
| 337
| 139,592
| 117,036
|
Accepted
|
Accepted
| 15.33
|
import sys
ris=lambda:list(map(int,next(sys.stdin).split()))
N,M,K=ris()
adj=[set() for _ in range(N)]
for _ in range(M):
A,B=ris()
A,B=A-1,B-1
adj[A].add(B)
adj[B].add(A)
colors=[-1]*N
ct={}
color=-1
for u in range(N):
if colors[u]!=-1:
continue
color+=1
colors[u]=color
stk=[u]
while stk:
u=stk.pop()
ct[color]=ct.get(color,0)+1
for v in adj[u]:
if colors[v]==-1:
colors[v]=color
stk.append(v)
blk=[{*()} for _ in range(N)]
for _ in range(K):
A,B=ris()
A,B=A-1,B-1
if colors[A]==colors[B]:
blk[A].add(B)
blk[B].add(A)
ans=[0]*N
for u in range(N):
c=colors[u]
g=len(adj[u])
b=len(blk[u])
k=ct[c]-1-g-b
ans[u]=k
print((*ans))
|
import sys
rl=lambda:next(sys.stdin)
rfs=lambda:rl().split()
ris=lambda:list(map(int,rfs()))
N,M,K=ris()
adj=[{*()} for _ in range(N)]
for _ in range(M):
A,B=ris()
A,B=A-1,B-1
adj[A].add(B)
adj[B].add(A)
c=-1
cs=[c]*N
ct={}
for u in range(N):
if cs[u]!=-1:
continue
c+=1
cs[u]=c
stk=[u]
while stk:
u=stk.pop()
if c not in ct:
ct[c]=0
ct[c]+=1
for v in adj[u]:
if cs[v]!=-1:
continue
cs[v]=c
stk.append(v)
ans=[0]*N
for u in range(N):
g=ct[cs[u]]-1
f=len(adj[u])
ans[u]=g-f
for _ in range(K):
A,B=ris()
A,B=A-1,B-1
if cs[A]==cs[B]:
ans[A]-=1
ans[B]-=1
print((*ans))
| 47
| 49
| 831
| 792
|
import sys
ris = lambda: list(map(int, next(sys.stdin).split()))
N, M, K = ris()
adj = [set() for _ in range(N)]
for _ in range(M):
A, B = ris()
A, B = A - 1, B - 1
adj[A].add(B)
adj[B].add(A)
colors = [-1] * N
ct = {}
color = -1
for u in range(N):
if colors[u] != -1:
continue
color += 1
colors[u] = color
stk = [u]
while stk:
u = stk.pop()
ct[color] = ct.get(color, 0) + 1
for v in adj[u]:
if colors[v] == -1:
colors[v] = color
stk.append(v)
blk = [{*()} for _ in range(N)]
for _ in range(K):
A, B = ris()
A, B = A - 1, B - 1
if colors[A] == colors[B]:
blk[A].add(B)
blk[B].add(A)
ans = [0] * N
for u in range(N):
c = colors[u]
g = len(adj[u])
b = len(blk[u])
k = ct[c] - 1 - g - b
ans[u] = k
print((*ans))
|
import sys
rl = lambda: next(sys.stdin)
rfs = lambda: rl().split()
ris = lambda: list(map(int, rfs()))
N, M, K = ris()
adj = [{*()} for _ in range(N)]
for _ in range(M):
A, B = ris()
A, B = A - 1, B - 1
adj[A].add(B)
adj[B].add(A)
c = -1
cs = [c] * N
ct = {}
for u in range(N):
if cs[u] != -1:
continue
c += 1
cs[u] = c
stk = [u]
while stk:
u = stk.pop()
if c not in ct:
ct[c] = 0
ct[c] += 1
for v in adj[u]:
if cs[v] != -1:
continue
cs[v] = c
stk.append(v)
ans = [0] * N
for u in range(N):
g = ct[cs[u]] - 1
f = len(adj[u])
ans[u] = g - f
for _ in range(K):
A, B = ris()
A, B = A - 1, B - 1
if cs[A] == cs[B]:
ans[A] -= 1
ans[B] -= 1
print((*ans))
| false
| 4.081633
|
[
"-ris = lambda: list(map(int, next(sys.stdin).split()))",
"+rl = lambda: next(sys.stdin)",
"+rfs = lambda: rl().split()",
"+ris = lambda: list(map(int, rfs()))",
"-adj = [set() for _ in range(N)]",
"+adj = [{*()} for _ in range(N)]",
"-colors = [-1] * N",
"+c = -1",
"+cs = [c] * N",
"-color = -1",
"- if colors[u] != -1:",
"+ if cs[u] != -1:",
"- color += 1",
"- colors[u] = color",
"+ c += 1",
"+ cs[u] = c",
"- ct[color] = ct.get(color, 0) + 1",
"+ if c not in ct:",
"+ ct[c] = 0",
"+ ct[c] += 1",
"- if colors[v] == -1:",
"- colors[v] = color",
"- stk.append(v)",
"-blk = [{*()} for _ in range(N)]",
"+ if cs[v] != -1:",
"+ continue",
"+ cs[v] = c",
"+ stk.append(v)",
"+ans = [0] * N",
"+for u in range(N):",
"+ g = ct[cs[u]] - 1",
"+ f = len(adj[u])",
"+ ans[u] = g - f",
"- if colors[A] == colors[B]:",
"- blk[A].add(B)",
"- blk[B].add(A)",
"-ans = [0] * N",
"-for u in range(N):",
"- c = colors[u]",
"- g = len(adj[u])",
"- b = len(blk[u])",
"- k = ct[c] - 1 - g - b",
"- ans[u] = k",
"+ if cs[A] == cs[B]:",
"+ ans[A] -= 1",
"+ ans[B] -= 1"
] | false
| 0.037419
| 0.047025
| 0.795718
|
[
"s250997492",
"s732442872"
] |
u162612857
|
p03652
|
python
|
s444010540
|
s316370091
| 1,744
| 1,510
| 10,164
| 10,272
|
Accepted
|
Accepted
| 13.42
|
# chokudaiブログの典型力の話を意識しつつ考えたら思いついた!
# 「ある集合の部分集合の中で、〜〜〜の値が最小になるものを求めよ」のパターン
# 愚直にやると2^Nを調べねばならず無理。
# したがって「一部を調べればよい」に帰着するのが多いだろう。
# 何らかの形でソートしておいて、空集合から1つずつ付け加えるとか。全体集合から1つずつ取り去るとか。
# 今回は全体集合から1つずつ取り去るのを考えるとできる。
# 全体集合である競技m0が最多の人数p0人を集めたとする。
# すると、全ての部分集合のうち「m0を含む集合」を考えると、競技m0は必ずp0人以上集まるので解もp0以上。
# ここで「m0を含む集合」について一気に計算できていることに注意! 一撃で多数の集合について計算が終わる。
# 次に全体集合からm0を取り去ったものを考える。
# ここである競技m1が最多の人数p1人を集めたとする。すると……以下同様。
# なお複数種目の競技が同率1位になった場合は全て一度に取り除いて良い。
# これで空集合までやって、最大が最小のものを出力すればOK!
n, m = list(map(int, input().split()))
preference = [list([int(x) - 1 for x in input().split()]) for _ in range(n)] # 1-index → 0-index
ans = n
held_sports = set(range(m))
while held_sports:
# 各競技に参加する人数を求める
parti = [0] * m
for person in range(n):
for s in range(m):
if preference[person][s] in held_sports:
parti[preference[person][s]] += 1
break
temp = max(parti)
ans = min(ans, temp)
# 集合から最大人数を取った要素を除外
for idx, par in enumerate(parti):
if par == temp:
held_sports.remove(idx)
print(ans)
|
# chokudaiブログの典型力の話を意識しつつ考えたら思いついた!
# 「ある集合の部分集合の中で、〜〜〜の値が最小になるものを求めよ」のパターン
# 愚直にやると2^Nを調べねばならず無理。
# したがって「一部を調べればよい」に帰着するのが多いだろう。
# 何らかの形でソートしておいて、空集合から1つずつ付け加えるとか。全体集合から1つずつ取り去るとか。
# 今回は全体集合から1つずつ取り去るのを考えるとできる。
# 全体集合である競技m0が最多の人数p0人を集めたとする。
# すると、全ての部分集合のうち「m0を含む集合」を考えると、競技m0は必ずp0人以上集まるので解もp0以上。
# ここで「m0を含む集合」について一気に計算できていることに注意! 一撃で多数の集合について計算が終わる。
# 次に全体集合からm0を取り去ったものを考える。
# ここである競技m1が最多の人数p1人を集めたとする。すると……以下同様。
# なお複数種目の競技が同率1位になった場合は全て一度に取り除いて良い。
# これで空集合までやって、最大が最小のものを出力すればOK!
n, m = list(map(int, input().split()))
preference = [list([int(x) - 1 for x in input().split()]) for _ in range(n)] # 1-index → 0-index
ans = n
held_sports = set(range(m))
while held_sports:
# 各競技に参加する人数を求める
parti = [0] * m
for pref in preference:
for s in range(m):
if pref[s] in held_sports:
parti[pref[s]] += 1
break
temp = max(parti)
ans = min(ans, temp)
# 集合から最大人数を取った要素を除外
for idx, par in enumerate(parti):
if par == temp:
held_sports.remove(idx)
print(ans)
| 39
| 39
| 1,135
| 1,107
|
# chokudaiブログの典型力の話を意識しつつ考えたら思いついた!
# 「ある集合の部分集合の中で、〜〜〜の値が最小になるものを求めよ」のパターン
# 愚直にやると2^Nを調べねばならず無理。
# したがって「一部を調べればよい」に帰着するのが多いだろう。
# 何らかの形でソートしておいて、空集合から1つずつ付け加えるとか。全体集合から1つずつ取り去るとか。
# 今回は全体集合から1つずつ取り去るのを考えるとできる。
# 全体集合である競技m0が最多の人数p0人を集めたとする。
# すると、全ての部分集合のうち「m0を含む集合」を考えると、競技m0は必ずp0人以上集まるので解もp0以上。
# ここで「m0を含む集合」について一気に計算できていることに注意! 一撃で多数の集合について計算が終わる。
# 次に全体集合からm0を取り去ったものを考える。
# ここである競技m1が最多の人数p1人を集めたとする。すると……以下同様。
# なお複数種目の競技が同率1位になった場合は全て一度に取り除いて良い。
# これで空集合までやって、最大が最小のものを出力すればOK!
n, m = list(map(int, input().split()))
preference = [
list([int(x) - 1 for x in input().split()]) for _ in range(n)
] # 1-index → 0-index
ans = n
held_sports = set(range(m))
while held_sports:
# 各競技に参加する人数を求める
parti = [0] * m
for person in range(n):
for s in range(m):
if preference[person][s] in held_sports:
parti[preference[person][s]] += 1
break
temp = max(parti)
ans = min(ans, temp)
# 集合から最大人数を取った要素を除外
for idx, par in enumerate(parti):
if par == temp:
held_sports.remove(idx)
print(ans)
|
# chokudaiブログの典型力の話を意識しつつ考えたら思いついた!
# 「ある集合の部分集合の中で、〜〜〜の値が最小になるものを求めよ」のパターン
# 愚直にやると2^Nを調べねばならず無理。
# したがって「一部を調べればよい」に帰着するのが多いだろう。
# 何らかの形でソートしておいて、空集合から1つずつ付け加えるとか。全体集合から1つずつ取り去るとか。
# 今回は全体集合から1つずつ取り去るのを考えるとできる。
# 全体集合である競技m0が最多の人数p0人を集めたとする。
# すると、全ての部分集合のうち「m0を含む集合」を考えると、競技m0は必ずp0人以上集まるので解もp0以上。
# ここで「m0を含む集合」について一気に計算できていることに注意! 一撃で多数の集合について計算が終わる。
# 次に全体集合からm0を取り去ったものを考える。
# ここである競技m1が最多の人数p1人を集めたとする。すると……以下同様。
# なお複数種目の競技が同率1位になった場合は全て一度に取り除いて良い。
# これで空集合までやって、最大が最小のものを出力すればOK!
n, m = list(map(int, input().split()))
preference = [
list([int(x) - 1 for x in input().split()]) for _ in range(n)
] # 1-index → 0-index
ans = n
held_sports = set(range(m))
while held_sports:
# 各競技に参加する人数を求める
parti = [0] * m
for pref in preference:
for s in range(m):
if pref[s] in held_sports:
parti[pref[s]] += 1
break
temp = max(parti)
ans = min(ans, temp)
# 集合から最大人数を取った要素を除外
for idx, par in enumerate(parti):
if par == temp:
held_sports.remove(idx)
print(ans)
| false
| 0
|
[
"- for person in range(n):",
"+ for pref in preference:",
"- if preference[person][s] in held_sports:",
"- parti[preference[person][s]] += 1",
"+ if pref[s] in held_sports:",
"+ parti[pref[s]] += 1"
] | false
| 0.044295
| 0.062668
| 0.706816
|
[
"s444010540",
"s316370091"
] |
u052499405
|
p03061
|
python
|
s293203028
|
s264209695
| 1,271
| 1,136
| 30,088
| 30,128
|
Accepted
|
Accepted
| 10.62
|
#!/usr/bin/env python3
import sys
from fractions import gcd
input = sys.stdin.readline
class DisjointSparseTable:
def __init__(self, a):
# Identity element
self.e = 0
self.level = (len(a) - 1).bit_length()
self.size = 2**self.level
self.table = [[self.e] * self.size for _ in range(self.level)]
# Set bottom first
for i, item in enumerate(a):
self.table[-1][i] = item
self.build()
def build(self):
for i in range(1, self.level):
step = 2**i
lv = self.level - 1 - i
for mid in range(step, self.size, step*2):
# Forward
val = self.e
for j in range(step):
val = gcd(self.table[-1][mid + j], val)
self.table[lv][mid + j] = val
# Backward
val = self.e
for j in range(step):
val = gcd(self.table[-1][mid - 1 - j], val)
self.table[lv][mid - 1 - j] = val
# Returns f[l:r)
def query(self, l, r):
if l == r:
return self.e
elif l == r - 1:
return self.table[-1][l]
lv = self.level - (l ^ r-1).bit_length()
return gcd(self.table[lv][l], self.table[lv][r-1])
if __name__ == "__main__":
n = int(eval(input()))
a = [int(item) for item in input().split()]
DST = DisjointSparseTable(a)
ans = 0
for i in range(0, n):
ans = max(ans, gcd(DST.query(0, i), DST.query(i+1, n)))
print(ans)
|
#!/usr/bin/env python3
import sys
from fractions import gcd
input = sys.stdin.readline
class DisjointSparseTable:
def __init__(self, a):
# Identity element
self.e = 0
self.n = len(a)
self.level = (len(a) - 1).bit_length()
self.size = 2**self.level
self.table = [[self.e] * self.size for _ in range(self.level)]
# Set bottom first
for i, item in enumerate(a):
self.table[-1][i] = item
self.build()
def build(self):
for i in range(1, self.level):
step = 2**i
lv = self.level - 1 - i
for mid in range(step, self.size, step*2):
if mid - step >= self.n:
continue
# Forward
val = self.e
for j in range(step):
val = gcd(self.table[-1][mid + j], val)
self.table[lv][mid + j] = val
# Backward
val = self.e
for j in range(step):
val = gcd(self.table[-1][mid - 1 - j], val)
self.table[lv][mid - 1 - j] = val
# Returns f[l:r)
def query(self, l, r):
if l == r:
return self.e
elif l == r - 1:
return self.table[-1][l]
lv = self.level - (l ^ r-1).bit_length()
return gcd(self.table[lv][l], self.table[lv][r-1])
if __name__ == "__main__":
n = int(eval(input()))
a = [int(item) for item in input().split()]
DST = DisjointSparseTable(a)
ans = 0
for i in range(0, n):
ans = max(ans, gcd(DST.query(0, i), DST.query(i+1, n)))
print(ans)
| 51
| 54
| 1,616
| 1,717
|
#!/usr/bin/env python3
import sys
from fractions import gcd
input = sys.stdin.readline
class DisjointSparseTable:
def __init__(self, a):
# Identity element
self.e = 0
self.level = (len(a) - 1).bit_length()
self.size = 2**self.level
self.table = [[self.e] * self.size for _ in range(self.level)]
# Set bottom first
for i, item in enumerate(a):
self.table[-1][i] = item
self.build()
def build(self):
for i in range(1, self.level):
step = 2**i
lv = self.level - 1 - i
for mid in range(step, self.size, step * 2):
# Forward
val = self.e
for j in range(step):
val = gcd(self.table[-1][mid + j], val)
self.table[lv][mid + j] = val
# Backward
val = self.e
for j in range(step):
val = gcd(self.table[-1][mid - 1 - j], val)
self.table[lv][mid - 1 - j] = val
# Returns f[l:r)
def query(self, l, r):
if l == r:
return self.e
elif l == r - 1:
return self.table[-1][l]
lv = self.level - (l ^ r - 1).bit_length()
return gcd(self.table[lv][l], self.table[lv][r - 1])
if __name__ == "__main__":
n = int(eval(input()))
a = [int(item) for item in input().split()]
DST = DisjointSparseTable(a)
ans = 0
for i in range(0, n):
ans = max(ans, gcd(DST.query(0, i), DST.query(i + 1, n)))
print(ans)
|
#!/usr/bin/env python3
import sys
from fractions import gcd
input = sys.stdin.readline
class DisjointSparseTable:
def __init__(self, a):
# Identity element
self.e = 0
self.n = len(a)
self.level = (len(a) - 1).bit_length()
self.size = 2**self.level
self.table = [[self.e] * self.size for _ in range(self.level)]
# Set bottom first
for i, item in enumerate(a):
self.table[-1][i] = item
self.build()
def build(self):
for i in range(1, self.level):
step = 2**i
lv = self.level - 1 - i
for mid in range(step, self.size, step * 2):
if mid - step >= self.n:
continue
# Forward
val = self.e
for j in range(step):
val = gcd(self.table[-1][mid + j], val)
self.table[lv][mid + j] = val
# Backward
val = self.e
for j in range(step):
val = gcd(self.table[-1][mid - 1 - j], val)
self.table[lv][mid - 1 - j] = val
# Returns f[l:r)
def query(self, l, r):
if l == r:
return self.e
elif l == r - 1:
return self.table[-1][l]
lv = self.level - (l ^ r - 1).bit_length()
return gcd(self.table[lv][l], self.table[lv][r - 1])
if __name__ == "__main__":
n = int(eval(input()))
a = [int(item) for item in input().split()]
DST = DisjointSparseTable(a)
ans = 0
for i in range(0, n):
ans = max(ans, gcd(DST.query(0, i), DST.query(i + 1, n)))
print(ans)
| false
| 5.555556
|
[
"+ self.n = len(a)",
"+ if mid - step >= self.n:",
"+ continue"
] | false
| 0.052337
| 0.059391
| 0.881239
|
[
"s293203028",
"s264209695"
] |
u905203728
|
p03286
|
python
|
s894649389
|
s669081971
| 186
| 17
| 38,384
| 2,940
|
Accepted
|
Accepted
| 90.86
|
n=int(eval(input()))
ans=""
if n==0:print("0");exit()
while n!=0:
ans +=str(n%2)
n=-(n//2)
print(("".join(ans[::-1])))
|
n=int(eval(input()))
ans=""
if n==0:print((0));exit()
while n!=0:
ans +=str(n%2)
n=-(n//2)
print((ans[::-1]))
| 7
| 9
| 124
| 117
|
n = int(eval(input()))
ans = ""
if n == 0:
print("0")
exit()
while n != 0:
ans += str(n % 2)
n = -(n // 2)
print(("".join(ans[::-1])))
|
n = int(eval(input()))
ans = ""
if n == 0:
print((0))
exit()
while n != 0:
ans += str(n % 2)
n = -(n // 2)
print((ans[::-1]))
| false
| 22.222222
|
[
"- print(\"0\")",
"+ print((0))",
"-print((\"\".join(ans[::-1])))",
"+print((ans[::-1]))"
] | false
| 0.053052
| 0.045674
| 1.161525
|
[
"s894649389",
"s669081971"
] |
u543954314
|
p02975
|
python
|
s949800185
|
s696545240
| 66
| 54
| 14,212
| 14,212
|
Accepted
|
Accepted
| 18.18
|
n = int(eval(input()))
l = list(map(int,input().split()))
if not any(l):
print("Yes")
elif n%3 != 0:
print("No")
else:
nx = n//3
d = dict()
for x in l:
if x not in d:
d[x] = 0
d[x] += 1
for x in d:
if d[x] != nx and d[x] !=2*nx:
print("No")
break
else:
s = 0
for x in d:
if d[x] == nx:
s ^= x
if s == 0:
print("Yes")
else:
print("No")
|
n = eval(input())
s = list(map(int, input().split()))
a = 0
for x in s:
a ^= x
if a==0:
print("Yes")
else:
print("No")
| 26
| 9
| 440
| 126
|
n = int(eval(input()))
l = list(map(int, input().split()))
if not any(l):
print("Yes")
elif n % 3 != 0:
print("No")
else:
nx = n // 3
d = dict()
for x in l:
if x not in d:
d[x] = 0
d[x] += 1
for x in d:
if d[x] != nx and d[x] != 2 * nx:
print("No")
break
else:
s = 0
for x in d:
if d[x] == nx:
s ^= x
if s == 0:
print("Yes")
else:
print("No")
|
n = eval(input())
s = list(map(int, input().split()))
a = 0
for x in s:
a ^= x
if a == 0:
print("Yes")
else:
print("No")
| false
| 65.384615
|
[
"-n = int(eval(input()))",
"-l = list(map(int, input().split()))",
"-if not any(l):",
"+n = eval(input())",
"+s = list(map(int, input().split()))",
"+a = 0",
"+for x in s:",
"+ a ^= x",
"+if a == 0:",
"-elif n % 3 != 0:",
"+else:",
"-else:",
"- nx = n // 3",
"- d = dict()",
"- for x in l:",
"- if x not in d:",
"- d[x] = 0",
"- d[x] += 1",
"- for x in d:",
"- if d[x] != nx and d[x] != 2 * nx:",
"- print(\"No\")",
"- break",
"- else:",
"- s = 0",
"- for x in d:",
"- if d[x] == nx:",
"- s ^= x",
"- if s == 0:",
"- print(\"Yes\")",
"- else:",
"- print(\"No\")"
] | false
| 0.033253
| 0.035916
| 0.925846
|
[
"s949800185",
"s696545240"
] |
u670961163
|
p02597
|
python
|
s528857812
|
s771820415
| 65
| 27
| 65,080
| 9,388
|
Accepted
|
Accepted
| 58.46
|
def main():
n = int(eval(input()))
s = eval(input())
wcount = s.count("W")
rcount = s.count("R")
ans = 0
for i in range(rcount):
if s[i] == "W":
ans+=1
print(ans)
if __name__ == "__main__":
main()
|
def main():
n = int(eval(input()))
s = eval(input())
rcount = s.count('R')
diff = s[0:rcount].count("W")
print(diff)
if __name__ == "__main__":
main()
| 17
| 13
| 257
| 179
|
def main():
n = int(eval(input()))
s = eval(input())
wcount = s.count("W")
rcount = s.count("R")
ans = 0
for i in range(rcount):
if s[i] == "W":
ans += 1
print(ans)
if __name__ == "__main__":
main()
|
def main():
n = int(eval(input()))
s = eval(input())
rcount = s.count("R")
diff = s[0:rcount].count("W")
print(diff)
if __name__ == "__main__":
main()
| false
| 23.529412
|
[
"- wcount = s.count(\"W\")",
"- ans = 0",
"- for i in range(rcount):",
"- if s[i] == \"W\":",
"- ans += 1",
"- print(ans)",
"+ diff = s[0:rcount].count(\"W\")",
"+ print(diff)"
] | false
| 0.037966
| 0.036735
| 1.03351
|
[
"s528857812",
"s771820415"
] |
u094999522
|
p03645
|
python
|
s893895868
|
s488270759
| 695
| 375
| 148,664
| 29,792
|
Accepted
|
Accepted
| 46.04
|
#!/usr/bin/env python3
from collections import deque
n, m = list(map(int, input().split()))
graph = [deque([]) for _ in range(n + 1)]
for _ in range(m):
a, b = list(map(int, input().split()))
graph[a].append(b)
graph[b].append(a)
for i in graph[1]:
if n in graph[i]:
print("POSSIBLE")
exit()
print("IMPOSSIBLE")
|
#!/usr/bin/env python3
n, m = input().split()
a = set()
b = set()
for _ in range(int(m)):
r = set(input().split())
if "1" in r:
a |= r
if n in r:
b |= r
print(("POSSIBLE" if len(a & b) > 0 else "IMPOSSIBLE"))
| 14
| 11
| 346
| 245
|
#!/usr/bin/env python3
from collections import deque
n, m = list(map(int, input().split()))
graph = [deque([]) for _ in range(n + 1)]
for _ in range(m):
a, b = list(map(int, input().split()))
graph[a].append(b)
graph[b].append(a)
for i in graph[1]:
if n in graph[i]:
print("POSSIBLE")
exit()
print("IMPOSSIBLE")
|
#!/usr/bin/env python3
n, m = input().split()
a = set()
b = set()
for _ in range(int(m)):
r = set(input().split())
if "1" in r:
a |= r
if n in r:
b |= r
print(("POSSIBLE" if len(a & b) > 0 else "IMPOSSIBLE"))
| false
| 21.428571
|
[
"-from collections import deque",
"-",
"-n, m = list(map(int, input().split()))",
"-graph = [deque([]) for _ in range(n + 1)]",
"-for _ in range(m):",
"- a, b = list(map(int, input().split()))",
"- graph[a].append(b)",
"- graph[b].append(a)",
"-for i in graph[1]:",
"- if n in graph[i]:",
"- print(\"POSSIBLE\")",
"- exit()",
"-print(\"IMPOSSIBLE\")",
"+n, m = input().split()",
"+a = set()",
"+b = set()",
"+for _ in range(int(m)):",
"+ r = set(input().split())",
"+ if \"1\" in r:",
"+ a |= r",
"+ if n in r:",
"+ b |= r",
"+print((\"POSSIBLE\" if len(a & b) > 0 else \"IMPOSSIBLE\"))"
] | false
| 0.040198
| 0.035284
| 1.139266
|
[
"s893895868",
"s488270759"
] |
u133936772
|
p02748
|
python
|
s286328293
|
s800849800
| 458
| 266
| 18,608
| 18,616
|
Accepted
|
Accepted
| 41.92
|
f=lambda:list(map(int,input().split()))
_,_,n=f()
a,b=list(f()),list(f())
m=min(a)+min(b)
for _ in range(n): x,y,c=f(); m=min(m,a[x-1]+b[y-1]-c)
print(m)
|
import sys
f=lambda:list(map(int,sys.stdin.readline().split()))
_,_,n=f()
a,b=list(f()),list(f())
m=min(a)+min(b)
for _ in range(n): x,y,c=f(); m=min(m,a[x-1]+b[y-1]-c)
print(m)
| 6
| 7
| 152
| 177
|
f = lambda: list(map(int, input().split()))
_, _, n = f()
a, b = list(f()), list(f())
m = min(a) + min(b)
for _ in range(n):
x, y, c = f()
m = min(m, a[x - 1] + b[y - 1] - c)
print(m)
|
import sys
f = lambda: list(map(int, sys.stdin.readline().split()))
_, _, n = f()
a, b = list(f()), list(f())
m = min(a) + min(b)
for _ in range(n):
x, y, c = f()
m = min(m, a[x - 1] + b[y - 1] - c)
print(m)
| false
| 14.285714
|
[
"-f = lambda: list(map(int, input().split()))",
"+import sys",
"+",
"+f = lambda: list(map(int, sys.stdin.readline().split()))"
] | false
| 0.035811
| 0.040412
| 0.886131
|
[
"s286328293",
"s800849800"
] |
u814271993
|
p02597
|
python
|
s349727698
|
s154251672
| 80
| 66
| 63,048
| 62,496
|
Accepted
|
Accepted
| 17.5
|
n=int(eval(input()))
c=eval(input())
r=c.count("R")
r_1=c[:r].count("R")
ans=r-r_1
print(ans)
|
n=int(eval(input()))
s = eval(input())
Ra = s.count('R')
t = s[:Ra]
Rb = t.count('R')
print((Ra-Rb))
| 6
| 6
| 86
| 91
|
n = int(eval(input()))
c = eval(input())
r = c.count("R")
r_1 = c[:r].count("R")
ans = r - r_1
print(ans)
|
n = int(eval(input()))
s = eval(input())
Ra = s.count("R")
t = s[:Ra]
Rb = t.count("R")
print((Ra - Rb))
| false
| 0
|
[
"-c = eval(input())",
"-r = c.count(\"R\")",
"-r_1 = c[:r].count(\"R\")",
"-ans = r - r_1",
"-print(ans)",
"+s = eval(input())",
"+Ra = s.count(\"R\")",
"+t = s[:Ra]",
"+Rb = t.count(\"R\")",
"+print((Ra - Rb))"
] | false
| 0.046948
| 0.04779
| 0.98237
|
[
"s349727698",
"s154251672"
] |
u888092736
|
p02609
|
python
|
s955581176
|
s694376532
| 1,384
| 892
| 9,520
| 9,344
|
Accepted
|
Accepted
| 35.55
|
def pop_count(n):
return sum(n >> i & 1 for i in range(n.bit_length()))
def f(n):
if n == 0:
return 0
return f(n % pop_count(n)) + 1
N = int(eval(input()))
X = eval(input())
p = X.count("1")
rem_plus = 0
rem_minus = 0
for i in range(N):
k = N - i - 1
if X[i] == "0":
continue
elif p > 1:
rem_minus = (rem_minus + pow(2, k, p - 1)) % (p - 1)
rem_plus = (rem_plus + pow(2, k, p + 1)) % (p + 1)
for i in range(N):
k = N - i - 1
if X[i] == "0":
print((f((rem_plus + pow(2, k, p + 1)) % (p + 1)) + 1))
elif p > 1:
print((f((rem_minus - pow(2, k, p - 1)) % (p - 1)) + 1))
else:
print((0))
|
def f(n):
if n == 0:
return 0
return f(n % bin(n).count("1")) + 1
N = int(eval(input()))
X = eval(input())
p = X.count("1")
rem_plus = 0
rem_minus = 0
for i in range(N):
k = N - i - 1
if X[i] == "0":
continue
elif p > 1:
rem_minus = (rem_minus + pow(2, k, p - 1)) % (p - 1)
rem_plus = (rem_plus + pow(2, k, p + 1)) % (p + 1)
for i in range(N):
k = N - i - 1
if X[i] == "0":
print((f((rem_plus + pow(2, k, p + 1)) % (p + 1)) + 1))
elif p > 1:
print((f((rem_minus - pow(2, k, p - 1)) % (p - 1)) + 1))
else:
print((0))
| 30
| 26
| 690
| 613
|
def pop_count(n):
return sum(n >> i & 1 for i in range(n.bit_length()))
def f(n):
if n == 0:
return 0
return f(n % pop_count(n)) + 1
N = int(eval(input()))
X = eval(input())
p = X.count("1")
rem_plus = 0
rem_minus = 0
for i in range(N):
k = N - i - 1
if X[i] == "0":
continue
elif p > 1:
rem_minus = (rem_minus + pow(2, k, p - 1)) % (p - 1)
rem_plus = (rem_plus + pow(2, k, p + 1)) % (p + 1)
for i in range(N):
k = N - i - 1
if X[i] == "0":
print((f((rem_plus + pow(2, k, p + 1)) % (p + 1)) + 1))
elif p > 1:
print((f((rem_minus - pow(2, k, p - 1)) % (p - 1)) + 1))
else:
print((0))
|
def f(n):
if n == 0:
return 0
return f(n % bin(n).count("1")) + 1
N = int(eval(input()))
X = eval(input())
p = X.count("1")
rem_plus = 0
rem_minus = 0
for i in range(N):
k = N - i - 1
if X[i] == "0":
continue
elif p > 1:
rem_minus = (rem_minus + pow(2, k, p - 1)) % (p - 1)
rem_plus = (rem_plus + pow(2, k, p + 1)) % (p + 1)
for i in range(N):
k = N - i - 1
if X[i] == "0":
print((f((rem_plus + pow(2, k, p + 1)) % (p + 1)) + 1))
elif p > 1:
print((f((rem_minus - pow(2, k, p - 1)) % (p - 1)) + 1))
else:
print((0))
| false
| 13.333333
|
[
"-def pop_count(n):",
"- return sum(n >> i & 1 for i in range(n.bit_length()))",
"-",
"-",
"- return f(n % pop_count(n)) + 1",
"+ return f(n % bin(n).count(\"1\")) + 1"
] | false
| 0.04003
| 0.037606
| 1.06447
|
[
"s955581176",
"s694376532"
] |
u630211216
|
p02684
|
python
|
s278667883
|
s202897892
| 1,895
| 186
| 339,504
| 32,328
|
Accepted
|
Accepted
| 90.18
|
N,K=list(map(int,input().split()))
A=list(map(int,input().split()))
move=[]
for i in range(0,N):
move.append([])
A[i]-=1
move[i].append(A[i])
for j in range(1,64):
for i in range(0,N):
move[i].append(move[move[i][j-1]][j-1])
town=0
for i in range(0,64):
if K%2==1:
town=move[town][i]
K//=2
print((town+1))
|
N,K=list(map(int,input().split()))
A=list(map(int,input().split()))
cycle=[]
for i in range(0,N):
cycle.append(-1)
A[i]-=1
count=0
cycle[0]=count
town=0
mod=0
while True:
count+=1
K-=1
town=A[town]
if K==0:
mod=1
break
if cycle[town]==-1:
cycle[town]=count
else:
mod=count-cycle[town]
break
K%=mod
while K>0:
town=A[town]
K-=1
print((town+1))
| 20
| 31
| 361
| 449
|
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
move = []
for i in range(0, N):
move.append([])
A[i] -= 1
move[i].append(A[i])
for j in range(1, 64):
for i in range(0, N):
move[i].append(move[move[i][j - 1]][j - 1])
town = 0
for i in range(0, 64):
if K % 2 == 1:
town = move[town][i]
K //= 2
print((town + 1))
|
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
cycle = []
for i in range(0, N):
cycle.append(-1)
A[i] -= 1
count = 0
cycle[0] = count
town = 0
mod = 0
while True:
count += 1
K -= 1
town = A[town]
if K == 0:
mod = 1
break
if cycle[town] == -1:
cycle[town] = count
else:
mod = count - cycle[town]
break
K %= mod
while K > 0:
town = A[town]
K -= 1
print((town + 1))
| false
| 35.483871
|
[
"-move = []",
"+cycle = []",
"- move.append([])",
"+ cycle.append(-1)",
"- move[i].append(A[i])",
"-for j in range(1, 64):",
"- for i in range(0, N):",
"- move[i].append(move[move[i][j - 1]][j - 1])",
"+count = 0",
"+cycle[0] = count",
"-for i in range(0, 64):",
"- if K % 2 == 1:",
"- town = move[town][i]",
"- K //= 2",
"+mod = 0",
"+while True:",
"+ count += 1",
"+ K -= 1",
"+ town = A[town]",
"+ if K == 0:",
"+ mod = 1",
"+ break",
"+ if cycle[town] == -1:",
"+ cycle[town] = count",
"+ else:",
"+ mod = count - cycle[town]",
"+ break",
"+K %= mod",
"+while K > 0:",
"+ town = A[town]",
"+ K -= 1"
] | false
| 0.071369
| 0.038315
| 1.862694
|
[
"s278667883",
"s202897892"
] |
u759434129
|
p02996
|
python
|
s315681649
|
s824736944
| 805
| 717
| 34,308
| 33,284
|
Accepted
|
Accepted
| 10.93
|
n = eval(input())
l = []
for i in range(n):
a, b = list(map(int, input().split()))
l.append((b, -a))
curtime = 0
l.sort()
for i in l:
if curtime - i[1] > i[0]:
print("No")
exit(0)
else:
curtime -= i[1]
print("Yes")
|
n = eval(input())
l = []
for i in range(n):
a, b = list(map(int, input().split()))
l.append((b, a))
curtime = 0
l.sort()
for i in l:
if curtime + i[1] > i[0]:
print("No")
exit(0)
else:
curtime += i[1]
print("Yes")
| 14
| 14
| 227
| 226
|
n = eval(input())
l = []
for i in range(n):
a, b = list(map(int, input().split()))
l.append((b, -a))
curtime = 0
l.sort()
for i in l:
if curtime - i[1] > i[0]:
print("No")
exit(0)
else:
curtime -= i[1]
print("Yes")
|
n = eval(input())
l = []
for i in range(n):
a, b = list(map(int, input().split()))
l.append((b, a))
curtime = 0
l.sort()
for i in l:
if curtime + i[1] > i[0]:
print("No")
exit(0)
else:
curtime += i[1]
print("Yes")
| false
| 0
|
[
"- l.append((b, -a))",
"+ l.append((b, a))",
"- if curtime - i[1] > i[0]:",
"+ if curtime + i[1] > i[0]:",
"- curtime -= i[1]",
"+ curtime += i[1]"
] | false
| 0.044259
| 0.043903
| 1.00811
|
[
"s315681649",
"s824736944"
] |
u172147273
|
p02720
|
python
|
s194937304
|
s604621308
| 575
| 404
| 52,308
| 59,484
|
Accepted
|
Accepted
| 29.74
|
import queue
q=queue.Queue()
K=int(eval(input()))
for i in range(1,10):q.put(i)
while(not q.empty()):
a=q.get()
K-=1
if K==0:
print(a)
exit()
for i in range(a%10-1,a%10+1+1):
if i<0 or i>9:continue
q.put(a*10+i)
|
import collections
ans=[]
s=collections.deque()
k=int(eval(input()))
ans.append(1)
for i in range(1,k):
for x in str(ans[i-1]):
s.append(int(x))
ls=len(s)-1
while ls>=0 and s[ls]==9:
s[ls]=0
ls-=1
if ls==-1:s.appendleft(1)
else:s[ls]+=1
while True:
b=-1
for i in range(0,len(s)-1):
if abs(s[i+1]-s[i])>1:
b=i
break
if b==-1:break
if s[b+1]>s[b]:s[b]+=1
l=max(s[b]-1,0)
for i in range(b+1,len(s)):
s[i]=l
l=max(l-1,0)
#print(s)
t=0
while len(s)>=1:
x=s.popleft()
#print("*",x)
t=t*10+x
ans.append(t)
print((ans[k-1]))
| 19
| 47
| 278
| 772
|
import queue
q = queue.Queue()
K = int(eval(input()))
for i in range(1, 10):
q.put(i)
while not q.empty():
a = q.get()
K -= 1
if K == 0:
print(a)
exit()
for i in range(a % 10 - 1, a % 10 + 1 + 1):
if i < 0 or i > 9:
continue
q.put(a * 10 + i)
|
import collections
ans = []
s = collections.deque()
k = int(eval(input()))
ans.append(1)
for i in range(1, k):
for x in str(ans[i - 1]):
s.append(int(x))
ls = len(s) - 1
while ls >= 0 and s[ls] == 9:
s[ls] = 0
ls -= 1
if ls == -1:
s.appendleft(1)
else:
s[ls] += 1
while True:
b = -1
for i in range(0, len(s) - 1):
if abs(s[i + 1] - s[i]) > 1:
b = i
break
if b == -1:
break
if s[b + 1] > s[b]:
s[b] += 1
l = max(s[b] - 1, 0)
for i in range(b + 1, len(s)):
s[i] = l
l = max(l - 1, 0)
# print(s)
t = 0
while len(s) >= 1:
x = s.popleft()
# print("*",x)
t = t * 10 + x
ans.append(t)
print((ans[k - 1]))
| false
| 59.574468
|
[
"-import queue",
"+import collections",
"-q = queue.Queue()",
"-K = int(eval(input()))",
"-for i in range(1, 10):",
"- q.put(i)",
"-while not q.empty():",
"- a = q.get()",
"- K -= 1",
"- if K == 0:",
"- print(a)",
"- exit()",
"- for i in range(a % 10 - 1, a % 10 + 1 + 1):",
"- if i < 0 or i > 9:",
"- continue",
"- q.put(a * 10 + i)",
"+ans = []",
"+s = collections.deque()",
"+k = int(eval(input()))",
"+ans.append(1)",
"+for i in range(1, k):",
"+ for x in str(ans[i - 1]):",
"+ s.append(int(x))",
"+ ls = len(s) - 1",
"+ while ls >= 0 and s[ls] == 9:",
"+ s[ls] = 0",
"+ ls -= 1",
"+ if ls == -1:",
"+ s.appendleft(1)",
"+ else:",
"+ s[ls] += 1",
"+ while True:",
"+ b = -1",
"+ for i in range(0, len(s) - 1):",
"+ if abs(s[i + 1] - s[i]) > 1:",
"+ b = i",
"+ break",
"+ if b == -1:",
"+ break",
"+ if s[b + 1] > s[b]:",
"+ s[b] += 1",
"+ l = max(s[b] - 1, 0)",
"+ for i in range(b + 1, len(s)):",
"+ s[i] = l",
"+ l = max(l - 1, 0)",
"+ # print(s)",
"+ t = 0",
"+ while len(s) >= 1:",
"+ x = s.popleft()",
"+ # print(\"*\",x)",
"+ t = t * 10 + x",
"+ ans.append(t)",
"+print((ans[k - 1]))"
] | false
| 0.193998
| 0.157456
| 1.232077
|
[
"s194937304",
"s604621308"
] |
u329565519
|
p03220
|
python
|
s413661909
|
s766815643
| 21
| 18
| 3,064
| 3,060
|
Accepted
|
Accepted
| 14.29
|
N = int(eval(input()))
T, A = list(map(int, input().split()))
H = list(map(int, input().split()))
mn = None
for i, h in enumerate(H):
d = abs(A - (T - h * 0.006))
mn = (i, d) if mn is None or mn[1] > d else mn
print((mn[0] + 1))
|
N = int(eval(input()))
T, A = list(map(int, input().split()))
H = list(map(int, input().split()))
mn = None
for i in range(N):
x = abs(A - (T - H[i] * 0.006))
if mn is None or x < mn[1]:
mn = (i, x)
print((mn[0] + 1))
| 10
| 10
| 233
| 229
|
N = int(eval(input()))
T, A = list(map(int, input().split()))
H = list(map(int, input().split()))
mn = None
for i, h in enumerate(H):
d = abs(A - (T - h * 0.006))
mn = (i, d) if mn is None or mn[1] > d else mn
print((mn[0] + 1))
|
N = int(eval(input()))
T, A = list(map(int, input().split()))
H = list(map(int, input().split()))
mn = None
for i in range(N):
x = abs(A - (T - H[i] * 0.006))
if mn is None or x < mn[1]:
mn = (i, x)
print((mn[0] + 1))
| false
| 0
|
[
"-for i, h in enumerate(H):",
"- d = abs(A - (T - h * 0.006))",
"- mn = (i, d) if mn is None or mn[1] > d else mn",
"+for i in range(N):",
"+ x = abs(A - (T - H[i] * 0.006))",
"+ if mn is None or x < mn[1]:",
"+ mn = (i, x)"
] | false
| 0.042568
| 0.042919
| 0.991821
|
[
"s413661909",
"s766815643"
] |
u466335531
|
p03338
|
python
|
s973128080
|
s666564913
| 22
| 18
| 3,060
| 3,060
|
Accepted
|
Accepted
| 18.18
|
N=int(eval(input()))
S=eval(input())
#Tに含まれた文字の種類を数える
def countletter(T):
S=[]
for t in T:
if t not in S:
S.append(t)
return len(S)
ans=0
for i in range(1,N):
A=S[:i]
B=S[i:]
ans=max(ans,countletter(A)+countletter(B)-countletter(S))
print(ans)
|
N=int(eval(input()))
S=eval(input())
ans=0
for i in range(1,N):
A=set(S[:i])
B=set(S[i:])
ans=max(ans,len(A&B))
print(ans)
| 20
| 8
| 307
| 129
|
N = int(eval(input()))
S = eval(input())
# Tに含まれた文字の種類を数える
def countletter(T):
S = []
for t in T:
if t not in S:
S.append(t)
return len(S)
ans = 0
for i in range(1, N):
A = S[:i]
B = S[i:]
ans = max(ans, countletter(A) + countletter(B) - countletter(S))
print(ans)
|
N = int(eval(input()))
S = eval(input())
ans = 0
for i in range(1, N):
A = set(S[:i])
B = set(S[i:])
ans = max(ans, len(A & B))
print(ans)
| false
| 60
|
[
"-# Tに含まれた文字の種類を数える",
"-def countletter(T):",
"- S = []",
"- for t in T:",
"- if t not in S:",
"- S.append(t)",
"- return len(S)",
"-",
"-",
"- A = S[:i]",
"- B = S[i:]",
"- ans = max(ans, countletter(A) + countletter(B) - countletter(S))",
"+ A = set(S[:i])",
"+ B = set(S[i:])",
"+ ans = max(ans, len(A & B))"
] | false
| 0.032785
| 0.037805
| 0.867202
|
[
"s973128080",
"s666564913"
] |
u992910889
|
p03999
|
python
|
s769374647
|
s777777103
| 186
| 20
| 40,176
| 3,064
|
Accepted
|
Accepted
| 89.25
|
import sys
sys.setrecursionlimit(10 ** 5 + 10)
def input(): return sys.stdin.readline().strip()
def resolve():
S = str(eval(input()))
ls=len(S)
# bit全探索
# https://qiita.com/gogotealove/items/11f9e83218926211083a#%E4%BE%8B%E9%A1%8C-1
n = ls-1
# 昇順での探索だよ
val = 0
for i in range(2 ** n):
split=[]
for j in range(n): # このループが一番のポイント
if ((i >> j) & 1): # 順に右にシフトさせ最下位bitのチェックを行う
split.append(j)
temp=0
for k in range(len(split)):
val+=int(S[temp:split[k]+1])
temp=split[k]+1
if k==len(split)-1:
val+=int(S[split[k]+1:])
print((val+int(S)))
resolve()
|
import sys
sys.setrecursionlimit(10 ** 5 + 10)
def input(): return sys.stdin.readline().strip()
def resolve():
def main():
S=str(eval(input()))
# bit全探索
# https://qiita.com/gogotealove/items/11f9e83218926211083a#%E4%BE%8B%E9%A1%8C-1
n = len(S)-1
if n==0:
return int(S)
else:
# 昇順での探索だよ
ans=0
for i in range(2 ** n):
temp = n+1
for j in range(n): # このループが一番のポイント
if ((i >> j) & 1):
ans+=int(S[-j-1:temp])
temp=-j-1
if j==n-1:
ans+=int(S[:temp])# 順
return ans# に右にシフトさせ最下位bitのチェックを行う
print((main()))
resolve()
| 30
| 29
| 721
| 792
|
import sys
sys.setrecursionlimit(10**5 + 10)
def input():
return sys.stdin.readline().strip()
def resolve():
S = str(eval(input()))
ls = len(S)
# bit全探索
# https://qiita.com/gogotealove/items/11f9e83218926211083a#%E4%BE%8B%E9%A1%8C-1
n = ls - 1
# 昇順での探索だよ
val = 0
for i in range(2**n):
split = []
for j in range(n): # このループが一番のポイント
if (i >> j) & 1: # 順に右にシフトさせ最下位bitのチェックを行う
split.append(j)
temp = 0
for k in range(len(split)):
val += int(S[temp : split[k] + 1])
temp = split[k] + 1
if k == len(split) - 1:
val += int(S[split[k] + 1 :])
print((val + int(S)))
resolve()
|
import sys
sys.setrecursionlimit(10**5 + 10)
def input():
return sys.stdin.readline().strip()
def resolve():
def main():
S = str(eval(input()))
# bit全探索
# https://qiita.com/gogotealove/items/11f9e83218926211083a#%E4%BE%8B%E9%A1%8C-1
n = len(S) - 1
if n == 0:
return int(S)
else:
# 昇順での探索だよ
ans = 0
for i in range(2**n):
temp = n + 1
for j in range(n): # このループが一番のポイント
if (i >> j) & 1:
ans += int(S[-j - 1 : temp])
temp = -j - 1
if j == n - 1:
ans += int(S[:temp]) # 順
return ans # に右にシフトさせ最下位bitのチェックを行う
print((main()))
resolve()
| false
| 3.333333
|
[
"- S = str(eval(input()))",
"- ls = len(S)",
"- # bit全探索",
"- # https://qiita.com/gogotealove/items/11f9e83218926211083a#%E4%BE%8B%E9%A1%8C-1",
"- n = ls - 1",
"- # 昇順での探索だよ",
"- val = 0",
"- for i in range(2**n):",
"- split = []",
"- for j in range(n): # このループが一番のポイント",
"- if (i >> j) & 1: # 順に右にシフトさせ最下位bitのチェックを行う",
"- split.append(j)",
"- temp = 0",
"- for k in range(len(split)):",
"- val += int(S[temp : split[k] + 1])",
"- temp = split[k] + 1",
"- if k == len(split) - 1:",
"- val += int(S[split[k] + 1 :])",
"- print((val + int(S)))",
"+ def main():",
"+ S = str(eval(input()))",
"+ # bit全探索",
"+ # https://qiita.com/gogotealove/items/11f9e83218926211083a#%E4%BE%8B%E9%A1%8C-1",
"+ n = len(S) - 1",
"+ if n == 0:",
"+ return int(S)",
"+ else:",
"+ # 昇順での探索だよ",
"+ ans = 0",
"+ for i in range(2**n):",
"+ temp = n + 1",
"+ for j in range(n): # このループが一番のポイント",
"+ if (i >> j) & 1:",
"+ ans += int(S[-j - 1 : temp])",
"+ temp = -j - 1",
"+ if j == n - 1:",
"+ ans += int(S[:temp]) # 順",
"+ return ans # に右にシフトさせ最下位bitのチェックを行う",
"+",
"+ print((main()))"
] | false
| 0.037749
| 0.038446
| 0.981879
|
[
"s769374647",
"s777777103"
] |
u342869120
|
p02623
|
python
|
s334112152
|
s833831266
| 198
| 182
| 122,220
| 123,888
|
Accepted
|
Accepted
| 8.08
|
import bisect
N, M, K = list(map(int, input().split()))
*A, = list(map(int, input().split()))
*B, = list(map(int, input().split()))
for i in range(1, N):
A[i] += A[i-1]
for i in range(1, M):
B[i] += B[i-1]
A = [0]+A
ans = 0
for i in range(N+1):
b = K-A[i]
if b < 0:
break
j = bisect.bisect_right(B, b)
if ans < (i+j):
ans = i+j
print(ans)
|
N, M, K = list(map(int, input().split()))
*A, = list(map(int, input().split()))
*B, = list(map(int, input().split()))
for i in range(1, N):
A[i] += A[i-1]
for i in range(1, M):
B[i] += B[i-1]
A = [0]+A
B = [0]+B
j = M
ans = 0
for i in range(N+1):
k = K-A[i]
if k < 0:
break
while B[j] > k:
j -= 1
ans = max(ans, i+j)
print(ans)
| 20
| 22
| 382
| 373
|
import bisect
N, M, K = list(map(int, input().split()))
(*A,) = list(map(int, input().split()))
(*B,) = list(map(int, input().split()))
for i in range(1, N):
A[i] += A[i - 1]
for i in range(1, M):
B[i] += B[i - 1]
A = [0] + A
ans = 0
for i in range(N + 1):
b = K - A[i]
if b < 0:
break
j = bisect.bisect_right(B, b)
if ans < (i + j):
ans = i + j
print(ans)
|
N, M, K = list(map(int, input().split()))
(*A,) = list(map(int, input().split()))
(*B,) = list(map(int, input().split()))
for i in range(1, N):
A[i] += A[i - 1]
for i in range(1, M):
B[i] += B[i - 1]
A = [0] + A
B = [0] + B
j = M
ans = 0
for i in range(N + 1):
k = K - A[i]
if k < 0:
break
while B[j] > k:
j -= 1
ans = max(ans, i + j)
print(ans)
| false
| 9.090909
|
[
"-import bisect",
"-",
"+B = [0] + B",
"+j = M",
"- b = K - A[i]",
"- if b < 0:",
"+ k = K - A[i]",
"+ if k < 0:",
"- j = bisect.bisect_right(B, b)",
"- if ans < (i + j):",
"- ans = i + j",
"+ while B[j] > k:",
"+ j -= 1",
"+ ans = max(ans, i + j)"
] | false
| 0.101447
| 0.09388
| 1.080596
|
[
"s334112152",
"s833831266"
] |
u808429775
|
p00118
|
python
|
s278697705
|
s391092316
| 80
| 70
| 5,992
| 5,992
|
Accepted
|
Accepted
| 12.5
|
def Labeling(terrain):
label = terrain
offset = [[-1, 0], [0, -1], [1, 0], [0, 1]]
signs = ["@", "#", "*"]
step = 0
for row in range(1, len(label) - 1):
for col in range(1, len(label[row]) - 1):
mark = label[row][col]
if mark in signs:
pointStack = [[row, col]]
label[row][col] = step
while 0 < len(pointStack):
rowIndex, colIndex = pointStack.pop()
for x, y in offset:
offsetRow, offsetCol = rowIndex + x, colIndex + y
if label[offsetRow][offsetCol] == mark:
pointStack.append([offsetRow, offsetCol])
label[offsetRow][offsetCol] = step
step += 1
return step
Sentinel = "1"
while True:
col, row = [int(item) for item in input().split()]
if row == 0 and col == 0:
break
land = []
land.append([item for item in Sentinel * row + Sentinel * 2])
for lp in range(col):
part = [item for item in eval(input())]
land.append([])
land[-1].extend([Sentinel])
land[-1].extend(part)
land[-1].extend([Sentinel])
land.append([item for item in Sentinel * row + Sentinel * 2])
result = Labeling(land)
print(result)
|
def Labeling(terrain):
label = terrain
offset = [[-1, 0], [0, -1], [1, 0], [0, 1]]
signs = ["@", "#", "*"]
rowLength, colLength = len(label) - 1, len(label[0]) - 1
step = 0
for row in range(1, rowLength):
for col in range(1, colLength):
mark = label[row][col]
if mark in signs:
pointStack = [[row, col]]
label[row][col] = step
while 0 < len(pointStack):
rowIndex, colIndex = pointStack.pop()
for x, y in offset:
offsetRow, offsetCol = rowIndex + x, colIndex + y
if label[offsetRow][offsetCol] == mark:
pointStack.append([offsetRow, offsetCol])
label[offsetRow][offsetCol] = step
step += 1
return step
Sentinel = "1"
while True:
col, row = [int(item) for item in input().split()]
if row == 0 and col == 0:
break
land = []
land.append([item for item in Sentinel * row + Sentinel * 2])
for lp in range(col):
part = [item for item in eval(input())]
land.append([])
land[-1].extend([Sentinel])
land[-1].extend(part)
land[-1].extend([Sentinel])
land.append([item for item in Sentinel * row + Sentinel * 2])
result = Labeling(land)
print(result)
| 55
| 57
| 1,408
| 1,457
|
def Labeling(terrain):
label = terrain
offset = [[-1, 0], [0, -1], [1, 0], [0, 1]]
signs = ["@", "#", "*"]
step = 0
for row in range(1, len(label) - 1):
for col in range(1, len(label[row]) - 1):
mark = label[row][col]
if mark in signs:
pointStack = [[row, col]]
label[row][col] = step
while 0 < len(pointStack):
rowIndex, colIndex = pointStack.pop()
for x, y in offset:
offsetRow, offsetCol = rowIndex + x, colIndex + y
if label[offsetRow][offsetCol] == mark:
pointStack.append([offsetRow, offsetCol])
label[offsetRow][offsetCol] = step
step += 1
return step
Sentinel = "1"
while True:
col, row = [int(item) for item in input().split()]
if row == 0 and col == 0:
break
land = []
land.append([item for item in Sentinel * row + Sentinel * 2])
for lp in range(col):
part = [item for item in eval(input())]
land.append([])
land[-1].extend([Sentinel])
land[-1].extend(part)
land[-1].extend([Sentinel])
land.append([item for item in Sentinel * row + Sentinel * 2])
result = Labeling(land)
print(result)
|
def Labeling(terrain):
label = terrain
offset = [[-1, 0], [0, -1], [1, 0], [0, 1]]
signs = ["@", "#", "*"]
rowLength, colLength = len(label) - 1, len(label[0]) - 1
step = 0
for row in range(1, rowLength):
for col in range(1, colLength):
mark = label[row][col]
if mark in signs:
pointStack = [[row, col]]
label[row][col] = step
while 0 < len(pointStack):
rowIndex, colIndex = pointStack.pop()
for x, y in offset:
offsetRow, offsetCol = rowIndex + x, colIndex + y
if label[offsetRow][offsetCol] == mark:
pointStack.append([offsetRow, offsetCol])
label[offsetRow][offsetCol] = step
step += 1
return step
Sentinel = "1"
while True:
col, row = [int(item) for item in input().split()]
if row == 0 and col == 0:
break
land = []
land.append([item for item in Sentinel * row + Sentinel * 2])
for lp in range(col):
part = [item for item in eval(input())]
land.append([])
land[-1].extend([Sentinel])
land[-1].extend(part)
land[-1].extend([Sentinel])
land.append([item for item in Sentinel * row + Sentinel * 2])
result = Labeling(land)
print(result)
| false
| 3.508772
|
[
"+ rowLength, colLength = len(label) - 1, len(label[0]) - 1",
"- for row in range(1, len(label) - 1):",
"- for col in range(1, len(label[row]) - 1):",
"+ for row in range(1, rowLength):",
"+ for col in range(1, colLength):"
] | false
| 0.101742
| 0.036713
| 2.771304
|
[
"s278697705",
"s391092316"
] |
u330661451
|
p03013
|
python
|
s095252435
|
s001080309
| 189
| 168
| 7,832
| 7,064
|
Accepted
|
Accepted
| 11.11
|
MOD = 1000000007
n , m = list(map(int,input().split()))
a = [0 for i in range(n+1)]
for i in range(m):
a[int(eval(input()))] = 1
count = [0 for i in range(n+1)]
for i in range(1,n+1):
if a[i] == 1:
continue
if i == 1:
count[i] = 1
elif i == 2:
count[i] = count[i-1] + 1
else:
count[i] = (count[i-1] + count[i-2]) % MOD
print((count[n]))
|
import sys
MOD = 1000000007
n , m = list(map(int,input().split()))
count = [0 for i in range(n+1)]
nxt = 0
def scount(s,e):
#print(s,e,file=sys.stderr)
global count
for i in range(s,e):
if i == 0:
count[i] = 1
elif i == 1:
count[i] = 1
else:
count[i] = (count[i-1] + count[i-2]) % MOD
for i in range(m):
a = int(eval(input()))
if nxt == a:
print((0))
exit(0)
scount(nxt,a)
nxt = a+1
scount(nxt,n+1)
#print(count,file=sys.stderr)
print((count[n]))
| 21
| 31
| 405
| 572
|
MOD = 1000000007
n, m = list(map(int, input().split()))
a = [0 for i in range(n + 1)]
for i in range(m):
a[int(eval(input()))] = 1
count = [0 for i in range(n + 1)]
for i in range(1, n + 1):
if a[i] == 1:
continue
if i == 1:
count[i] = 1
elif i == 2:
count[i] = count[i - 1] + 1
else:
count[i] = (count[i - 1] + count[i - 2]) % MOD
print((count[n]))
|
import sys
MOD = 1000000007
n, m = list(map(int, input().split()))
count = [0 for i in range(n + 1)]
nxt = 0
def scount(s, e):
# print(s,e,file=sys.stderr)
global count
for i in range(s, e):
if i == 0:
count[i] = 1
elif i == 1:
count[i] = 1
else:
count[i] = (count[i - 1] + count[i - 2]) % MOD
for i in range(m):
a = int(eval(input()))
if nxt == a:
print((0))
exit(0)
scount(nxt, a)
nxt = a + 1
scount(nxt, n + 1)
# print(count,file=sys.stderr)
print((count[n]))
| false
| 32.258065
|
[
"+import sys",
"+",
"-a = [0 for i in range(n + 1)]",
"+count = [0 for i in range(n + 1)]",
"+nxt = 0",
"+",
"+",
"+def scount(s, e):",
"+ # print(s,e,file=sys.stderr)",
"+ global count",
"+ for i in range(s, e):",
"+ if i == 0:",
"+ count[i] = 1",
"+ elif i == 1:",
"+ count[i] = 1",
"+ else:",
"+ count[i] = (count[i - 1] + count[i - 2]) % MOD",
"+",
"+",
"- a[int(eval(input()))] = 1",
"-count = [0 for i in range(n + 1)]",
"-for i in range(1, n + 1):",
"- if a[i] == 1:",
"- continue",
"- if i == 1:",
"- count[i] = 1",
"- elif i == 2:",
"- count[i] = count[i - 1] + 1",
"- else:",
"- count[i] = (count[i - 1] + count[i - 2]) % MOD",
"+ a = int(eval(input()))",
"+ if nxt == a:",
"+ print((0))",
"+ exit(0)",
"+ scount(nxt, a)",
"+ nxt = a + 1",
"+scount(nxt, n + 1)",
"+# print(count,file=sys.stderr)"
] | false
| 0.046041
| 0.046665
| 0.986628
|
[
"s095252435",
"s001080309"
] |
u078349616
|
p02725
|
python
|
s352509496
|
s234142252
| 247
| 139
| 26,444
| 26,436
|
Accepted
|
Accepted
| 43.72
|
K, N = list(map(int, input().split()))
A = list(map(int,input().split()))
for i in range(N):
A.append(A[i]+K)
d = [0]*(N)
max_d, max_i = 0, -1
for i in range(N):
d[i] = A[i+1] - A[i]
if d[i] > max_d:
max_d = d[i]
max_i = i + 1
ans = 0
for i in range(N-1):
ans += A[i+max_i+1] - A[i+max_i]
print(ans)
|
K, N = list(map(int, input().split()))
A = list(map(int,input().split()))
A.append(A[0] + K)
d = 0
for i in range(N):
d = max(d, A[i+1] - A[i])
print((K - d))
| 15
| 7
| 323
| 157
|
K, N = list(map(int, input().split()))
A = list(map(int, input().split()))
for i in range(N):
A.append(A[i] + K)
d = [0] * (N)
max_d, max_i = 0, -1
for i in range(N):
d[i] = A[i + 1] - A[i]
if d[i] > max_d:
max_d = d[i]
max_i = i + 1
ans = 0
for i in range(N - 1):
ans += A[i + max_i + 1] - A[i + max_i]
print(ans)
|
K, N = list(map(int, input().split()))
A = list(map(int, input().split()))
A.append(A[0] + K)
d = 0
for i in range(N):
d = max(d, A[i + 1] - A[i])
print((K - d))
| false
| 53.333333
|
[
"+A.append(A[0] + K)",
"+d = 0",
"- A.append(A[i] + K)",
"-d = [0] * (N)",
"-max_d, max_i = 0, -1",
"-for i in range(N):",
"- d[i] = A[i + 1] - A[i]",
"- if d[i] > max_d:",
"- max_d = d[i]",
"- max_i = i + 1",
"-ans = 0",
"-for i in range(N - 1):",
"- ans += A[i + max_i + 1] - A[i + max_i]",
"-print(ans)",
"+ d = max(d, A[i + 1] - A[i])",
"+print((K - d))"
] | false
| 0.077385
| 0.038605
| 2.004503
|
[
"s352509496",
"s234142252"
] |
u762420987
|
p02820
|
python
|
s164422768
|
s827539629
| 128
| 103
| 12,708
| 4,212
|
Accepted
|
Accepted
| 19.53
|
N, K = list(map(int, input().split()))
R, S, P = list(map(int, input().split()))
T = list(eval(input()))
sp_T = []
for i in range(K):
sp_T.append(T[i::K])
ans = 0
win_d = {"s": "r", "r": "p", "p": "s"}
point = {"r": R, "s": S, "p": P}
for t in sp_T:
sakki = ""
for i in range(len(t)):
if win_d[t[i]] != sakki:
my_hand = win_d[t[i]]
ans += point[my_hand]
sakki = my_hand
else:
if i == len(t) - 1:
pass
else:
next_want_hand = win_d[t[i + 1]]
if sakki == next_want_hand:
sakki = "X"
else:
sakki = "X"
print(ans)
|
N, K = list(map(int, input().split()))
R, S, P = list(map(int, input().split()))
score = {"r": P, "s": R, "p": S, "x": 0}
T = eval(input())
ans = 0
for i in range(K):
temp = []
for j in range(i, N, K):
if not temp:
temp.append(T[j])
else:
if temp[-1] == T[j]:
temp.append("x")
else:
temp.append(T[j])
ans += score[temp[-1]]
print(ans)
| 26
| 19
| 708
| 436
|
N, K = list(map(int, input().split()))
R, S, P = list(map(int, input().split()))
T = list(eval(input()))
sp_T = []
for i in range(K):
sp_T.append(T[i::K])
ans = 0
win_d = {"s": "r", "r": "p", "p": "s"}
point = {"r": R, "s": S, "p": P}
for t in sp_T:
sakki = ""
for i in range(len(t)):
if win_d[t[i]] != sakki:
my_hand = win_d[t[i]]
ans += point[my_hand]
sakki = my_hand
else:
if i == len(t) - 1:
pass
else:
next_want_hand = win_d[t[i + 1]]
if sakki == next_want_hand:
sakki = "X"
else:
sakki = "X"
print(ans)
|
N, K = list(map(int, input().split()))
R, S, P = list(map(int, input().split()))
score = {"r": P, "s": R, "p": S, "x": 0}
T = eval(input())
ans = 0
for i in range(K):
temp = []
for j in range(i, N, K):
if not temp:
temp.append(T[j])
else:
if temp[-1] == T[j]:
temp.append("x")
else:
temp.append(T[j])
ans += score[temp[-1]]
print(ans)
| false
| 26.923077
|
[
"-T = list(eval(input()))",
"-sp_T = []",
"+score = {\"r\": P, \"s\": R, \"p\": S, \"x\": 0}",
"+T = eval(input())",
"+ans = 0",
"- sp_T.append(T[i::K])",
"-ans = 0",
"-win_d = {\"s\": \"r\", \"r\": \"p\", \"p\": \"s\"}",
"-point = {\"r\": R, \"s\": S, \"p\": P}",
"-for t in sp_T:",
"- sakki = \"\"",
"- for i in range(len(t)):",
"- if win_d[t[i]] != sakki:",
"- my_hand = win_d[t[i]]",
"- ans += point[my_hand]",
"- sakki = my_hand",
"+ temp = []",
"+ for j in range(i, N, K):",
"+ if not temp:",
"+ temp.append(T[j])",
"- if i == len(t) - 1:",
"- pass",
"+ if temp[-1] == T[j]:",
"+ temp.append(\"x\")",
"- next_want_hand = win_d[t[i + 1]]",
"- if sakki == next_want_hand:",
"- sakki = \"X\"",
"- else:",
"- sakki = \"X\"",
"+ temp.append(T[j])",
"+ ans += score[temp[-1]]"
] | false
| 0.057628
| 0.037191
| 1.549504
|
[
"s164422768",
"s827539629"
] |
u775681539
|
p03038
|
python
|
s925228336
|
s935090246
| 597
| 515
| 28,636
| 28,888
|
Accepted
|
Accepted
| 13.74
|
#python3
from heapq import heappop, heappush
def main():
n, m = list(map(int, input().split()))
hq = []
for i in input().split():
heappush(hq, (-int(i), 1))
for _ in range(m):
b, c = list(map(int, input().split()))
heappush(hq, (-c, b))
ans = 0
for i in range(n):
v, u = heappop(hq)
u = u - 1
if u >= 1:
heappush(hq, (v, u))
v = - v
ans = ans + v
print(ans)
main()
|
#python3
def main():
n, m = list(map(int, input().split()))
cards = [(int(i), 1) for i in input().split()]
for _ in range(m):
b, c = list(map(int, input().split()))
cards.append((c, b))
cards.sort(reverse=True)
ans = 0
sumv = 0
for i in range(n):
v = cards[i][1]
cv = cards[i][0] * v
ans += cv
sumv += v
if sumv >= n:
ans -= cards[i][0] * (sumv - n)
break
print(ans)
main()
| 21
| 20
| 480
| 492
|
# python3
from heapq import heappop, heappush
def main():
n, m = list(map(int, input().split()))
hq = []
for i in input().split():
heappush(hq, (-int(i), 1))
for _ in range(m):
b, c = list(map(int, input().split()))
heappush(hq, (-c, b))
ans = 0
for i in range(n):
v, u = heappop(hq)
u = u - 1
if u >= 1:
heappush(hq, (v, u))
v = -v
ans = ans + v
print(ans)
main()
|
# python3
def main():
n, m = list(map(int, input().split()))
cards = [(int(i), 1) for i in input().split()]
for _ in range(m):
b, c = list(map(int, input().split()))
cards.append((c, b))
cards.sort(reverse=True)
ans = 0
sumv = 0
for i in range(n):
v = cards[i][1]
cv = cards[i][0] * v
ans += cv
sumv += v
if sumv >= n:
ans -= cards[i][0] * (sumv - n)
break
print(ans)
main()
| false
| 4.761905
|
[
"-from heapq import heappop, heappush",
"-",
"-",
"- hq = []",
"- for i in input().split():",
"- heappush(hq, (-int(i), 1))",
"+ cards = [(int(i), 1) for i in input().split()]",
"- heappush(hq, (-c, b))",
"+ cards.append((c, b))",
"+ cards.sort(reverse=True)",
"+ sumv = 0",
"- v, u = heappop(hq)",
"- u = u - 1",
"- if u >= 1:",
"- heappush(hq, (v, u))",
"- v = -v",
"- ans = ans + v",
"+ v = cards[i][1]",
"+ cv = cards[i][0] * v",
"+ ans += cv",
"+ sumv += v",
"+ if sumv >= n:",
"+ ans -= cards[i][0] * (sumv - n)",
"+ break"
] | false
| 0.044211
| 0.04825
| 0.916301
|
[
"s925228336",
"s935090246"
] |
u477977638
|
p02937
|
python
|
s695531609
|
s557659970
| 153
| 96
| 7,916
| 8,048
|
Accepted
|
Accepted
| 37.25
|
from collections import defaultdict
import bisect
d=defaultdict(list)
s=eval(input())
t=eval(input())
ns=len(s)
nt=len(t)
for i in range(ns):
d[s[i]].append(i)
for k,v in list(d.items()):
d[k].append(ns)
#print(d)
ans=0
cnt=-1
for i in range(nt):
tt=d[t[i]]
# print(t[i],tt,ans,cnt)
if tt==[]:
print((-1))
exit(0)
else:
a=bisect.bisect_right(tt,cnt)
# print("ind",a)
if tt[a]==ns:
ans+=ns+tt[0]-cnt
cnt=tt[0]
else:
ans+=tt[a]-cnt
cnt=tt[a]
print(ans)
|
import sys
#input = sys.stdin.readline
input = sys.stdin.buffer.readline
# mod=10**9+7
# rstrip().decode('utf-8')
# map(int,input().split())
# import numpy as np
from collections import defaultdict
import bisect
def main():
s=input().rstrip().decode('utf-8')
t=input().rstrip().decode('utf-8')
D=defaultdict(list)
for i in range(len(s)):
D[s[i]].append(i+1)
now=0
cnt=0
for i in t:
if D[i]==[]:
print((-1))
exit(0)
else:
idx=bisect.bisect_right(D[i],now)
try:
now=D[i][idx]
except:
now=D[i][0]
cnt+=1
print((cnt*len(s)+now))
if __name__ == "__main__":
main()
| 39
| 54
| 547
| 673
|
from collections import defaultdict
import bisect
d = defaultdict(list)
s = eval(input())
t = eval(input())
ns = len(s)
nt = len(t)
for i in range(ns):
d[s[i]].append(i)
for k, v in list(d.items()):
d[k].append(ns)
# print(d)
ans = 0
cnt = -1
for i in range(nt):
tt = d[t[i]]
# print(t[i],tt,ans,cnt)
if tt == []:
print((-1))
exit(0)
else:
a = bisect.bisect_right(tt, cnt)
# print("ind",a)
if tt[a] == ns:
ans += ns + tt[0] - cnt
cnt = tt[0]
else:
ans += tt[a] - cnt
cnt = tt[a]
print(ans)
|
import sys
# input = sys.stdin.readline
input = sys.stdin.buffer.readline
# mod=10**9+7
# rstrip().decode('utf-8')
# map(int,input().split())
# import numpy as np
from collections import defaultdict
import bisect
def main():
s = input().rstrip().decode("utf-8")
t = input().rstrip().decode("utf-8")
D = defaultdict(list)
for i in range(len(s)):
D[s[i]].append(i + 1)
now = 0
cnt = 0
for i in t:
if D[i] == []:
print((-1))
exit(0)
else:
idx = bisect.bisect_right(D[i], now)
try:
now = D[i][idx]
except:
now = D[i][0]
cnt += 1
print((cnt * len(s) + now))
if __name__ == "__main__":
main()
| false
| 27.777778
|
[
"+import sys",
"+",
"+# input = sys.stdin.readline",
"+input = sys.stdin.buffer.readline",
"+# mod=10**9+7",
"+# rstrip().decode('utf-8')",
"+# map(int,input().split())",
"+# import numpy as np",
"-d = defaultdict(list)",
"-s = eval(input())",
"-t = eval(input())",
"-ns = len(s)",
"-nt = len(t)",
"-for i in range(ns):",
"- d[s[i]].append(i)",
"-for k, v in list(d.items()):",
"- d[k].append(ns)",
"-# print(d)",
"-ans = 0",
"-cnt = -1",
"-for i in range(nt):",
"- tt = d[t[i]]",
"- # print(t[i],tt,ans,cnt)",
"- if tt == []:",
"- print((-1))",
"- exit(0)",
"- else:",
"- a = bisect.bisect_right(tt, cnt)",
"- # print(\"ind\",a)",
"- if tt[a] == ns:",
"- ans += ns + tt[0] - cnt",
"- cnt = tt[0]",
"+",
"+def main():",
"+ s = input().rstrip().decode(\"utf-8\")",
"+ t = input().rstrip().decode(\"utf-8\")",
"+ D = defaultdict(list)",
"+ for i in range(len(s)):",
"+ D[s[i]].append(i + 1)",
"+ now = 0",
"+ cnt = 0",
"+ for i in t:",
"+ if D[i] == []:",
"+ print((-1))",
"+ exit(0)",
"- ans += tt[a] - cnt",
"- cnt = tt[a]",
"-print(ans)",
"+ idx = bisect.bisect_right(D[i], now)",
"+ try:",
"+ now = D[i][idx]",
"+ except:",
"+ now = D[i][0]",
"+ cnt += 1",
"+ print((cnt * len(s) + now))",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false
| 0.046128
| 0.110406
| 0.417805
|
[
"s695531609",
"s557659970"
] |
u163783894
|
p03354
|
python
|
s833204773
|
s503105741
| 277
| 237
| 102,908
| 106,232
|
Accepted
|
Accepted
| 14.44
|
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
in_n = lambda: int(readline())
in_nn = lambda: list(map(int, readline().split()))
in_nl = lambda: list(map(int, readline().split()))
in_na = lambda: list(map(int, read().split()))
in_s = lambda: readline().rstrip().decode('utf-8')
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def main():
N, M = in_nn()
p = in_nl()
uni = UnionFind(N)
for i in range(M):
x, y = in_nn()
x, y = x - 1, y - 1
uni.union(x, y)
edge = [[] for i in range(N)]
for i in range(N):
x = uni.find(i)
edge[x].append(i)
ans = 0
for i in range(N):
if edge[i]:
s = set(edge[i])
for e in edge[i]:
if p[e] - 1 in s:
ans += 1
print(ans)
if __name__ == '__main__':
main()
|
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
in_n = lambda: int(readline())
in_nn = lambda: list(map(int, readline().split()))
in_nl = lambda: list(map(int, readline().split()))
in_na = lambda: list(map(int, read().split()))
in_s = lambda: readline().rstrip().decode('utf-8')
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
ret = dict()
for i in range(self.n):
r = self.find(i)
if r in ret:
ret[r].append(i)
else:
ret[r] = [i]
return ret
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def main():
N, M = in_nn()
p = in_nl()
uni = UnionFind(N)
for i in range(M):
x, y = in_nn()
x, y = x - 1, y - 1
uni.union(x, y)
ans = 0
for root, group in list(uni.all_group_members().items()):
s = set(group)
for g in group:
if p[g] - 1 in s:
ans += 1
print(ans)
if __name__ == '__main__':
main()
| 88
| 89
| 2,046
| 2,080
|
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
in_n = lambda: int(readline())
in_nn = lambda: list(map(int, readline().split()))
in_nl = lambda: list(map(int, readline().split()))
in_na = lambda: list(map(int, read().split()))
in_s = lambda: readline().rstrip().decode("utf-8")
class UnionFind:
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return "\n".join("{}: {}".format(r, self.members(r)) for r in self.roots())
def main():
N, M = in_nn()
p = in_nl()
uni = UnionFind(N)
for i in range(M):
x, y = in_nn()
x, y = x - 1, y - 1
uni.union(x, y)
edge = [[] for i in range(N)]
for i in range(N):
x = uni.find(i)
edge[x].append(i)
ans = 0
for i in range(N):
if edge[i]:
s = set(edge[i])
for e in edge[i]:
if p[e] - 1 in s:
ans += 1
print(ans)
if __name__ == "__main__":
main()
|
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
in_n = lambda: int(readline())
in_nn = lambda: list(map(int, readline().split()))
in_nl = lambda: list(map(int, readline().split()))
in_na = lambda: list(map(int, read().split()))
in_s = lambda: readline().rstrip().decode("utf-8")
class UnionFind:
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
ret = dict()
for i in range(self.n):
r = self.find(i)
if r in ret:
ret[r].append(i)
else:
ret[r] = [i]
return ret
def __str__(self):
return "\n".join("{}: {}".format(r, self.members(r)) for r in self.roots())
def main():
N, M = in_nn()
p = in_nl()
uni = UnionFind(N)
for i in range(M):
x, y = in_nn()
x, y = x - 1, y - 1
uni.union(x, y)
ans = 0
for root, group in list(uni.all_group_members().items()):
s = set(group)
for g in group:
if p[g] - 1 in s:
ans += 1
print(ans)
if __name__ == "__main__":
main()
| false
| 1.123596
|
[
"- return {r: self.members(r) for r in self.roots()}",
"+ ret = dict()",
"+ for i in range(self.n):",
"+ r = self.find(i)",
"+ if r in ret:",
"+ ret[r].append(i)",
"+ else:",
"+ ret[r] = [i]",
"+ return ret",
"- edge = [[] for i in range(N)]",
"- for i in range(N):",
"- x = uni.find(i)",
"- edge[x].append(i)",
"- for i in range(N):",
"- if edge[i]:",
"- s = set(edge[i])",
"- for e in edge[i]:",
"- if p[e] - 1 in s:",
"- ans += 1",
"+ for root, group in list(uni.all_group_members().items()):",
"+ s = set(group)",
"+ for g in group:",
"+ if p[g] - 1 in s:",
"+ ans += 1"
] | false
| 0.049337
| 0.111323
| 0.44319
|
[
"s833204773",
"s503105741"
] |
u512212329
|
p02572
|
python
|
s020019064
|
s234122198
| 142
| 129
| 31,476
| 31,716
|
Accepted
|
Accepted
| 9.15
|
from itertools import accumulate
def main():
n = int(eval(input()))
array = [int(x) for x in input().split()]
acc = accumulate(array)
mod = 10 ** 9 + 7
ans = 0
for i, ai in enumerate(acc):
if i == n - 1:
continue
ans += ai * array[i + 1]
ans %= mod
return ans
if __name__ == '__main__':
print((main()))
|
def main():
eval(input()) # n
array = [int(x) for x in input().split()]
mod = 10 ** 9 + 7
total = 0
center_blocks = 0
for x in array:
total += x
center_blocks += x ** 2
total = total ** 2
return (total - center_blocks) // 2 % mod
if __name__ == '__main__':
print((main()))
| 19
| 15
| 385
| 334
|
from itertools import accumulate
def main():
n = int(eval(input()))
array = [int(x) for x in input().split()]
acc = accumulate(array)
mod = 10**9 + 7
ans = 0
for i, ai in enumerate(acc):
if i == n - 1:
continue
ans += ai * array[i + 1]
ans %= mod
return ans
if __name__ == "__main__":
print((main()))
|
def main():
eval(input()) # n
array = [int(x) for x in input().split()]
mod = 10**9 + 7
total = 0
center_blocks = 0
for x in array:
total += x
center_blocks += x**2
total = total**2
return (total - center_blocks) // 2 % mod
if __name__ == "__main__":
print((main()))
| false
| 21.052632
|
[
"-from itertools import accumulate",
"-",
"-",
"- n = int(eval(input()))",
"+ eval(input()) # n",
"- acc = accumulate(array)",
"- ans = 0",
"- for i, ai in enumerate(acc):",
"- if i == n - 1:",
"- continue",
"- ans += ai * array[i + 1]",
"- ans %= mod",
"- return ans",
"+ total = 0",
"+ center_blocks = 0",
"+ for x in array:",
"+ total += x",
"+ center_blocks += x**2",
"+ total = total**2",
"+ return (total - center_blocks) // 2 % mod"
] | false
| 0.038015
| 0.042501
| 0.894447
|
[
"s020019064",
"s234122198"
] |
u303039933
|
p02912
|
python
|
s896691498
|
s237237338
| 486
| 129
| 90,788
| 21,884
|
Accepted
|
Accepted
| 73.46
|
# -*- coding: utf-8 -*-
import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from functools import lru_cache
import bisect
import re
import queue
from decimal import *
class Scanner():
@staticmethod
def int():
return int(sys.stdin.readline().rstrip())
@staticmethod
def string():
return sys.stdin.readline().rstrip()
@staticmethod
def map_int():
return [int(x) for x in Scanner.string().split()]
@staticmethod
def string_list(n):
return [eval(input()) for i in range(n)]
@staticmethod
def int_list_list(n):
return [Scanner.map_int() for i in range(n)]
@staticmethod
def int_cols_list(n):
return [int(eval(input())) for i in range(n)]
class Math():
@staticmethod
def gcd(a, b):
if b == 0:
return a
return Math.gcd(b, a % b)
@staticmethod
def lcm(a, b):
return (a * b) // Math.gcd(a, b)
@staticmethod
def divisor(n):
res = []
i = 1
for i in range(1, int(n ** 0.5) + 1):
if n % i == 0:
res.append(i)
if i != n // i:
res.append(n // i)
return res
@staticmethod
def round_up(a, b):
return -(-a // b)
@staticmethod
def is_prime(n):
if n < 2:
return False
if n == 2:
return True
if n % 2 == 0:
return False
d = int(n ** 0.5) + 1
for i in range(3, d + 1, 2):
if n % i == 0:
return False
return True
def pop_count(x):
x = x - ((x >> 1) & 0x5555555555555555)
x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)
x = (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f
x = x + (x >> 8)
x = x + (x >> 16)
x = x + (x >> 32)
return x & 0x0000007f
MOD = int(1e09) + 7
INF = int(1e15)
def main():
# sys.stdin = open("sample.txt")
N, M = Scanner.map_int()
A = [-a for a in Scanner.map_int()]
heapq.heapify(A)
for _ in range(M):
a = heapq.heappop(A)
a = -(-a // 2)
heapq.heappush(A, a)
print((-sum(A)))
if __name__ == "__main__":
main()
|
# -*- coding: utf-8 -*-
import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from collections import deque
from functools import lru_cache
import bisect
import re
import queue
import decimal
class Scanner():
@staticmethod
def int():
return int(sys.stdin.readline().rstrip())
@staticmethod
def string():
return sys.stdin.readline().rstrip()
@staticmethod
def map_int():
return [int(x) for x in Scanner.string().split()]
@staticmethod
def string_list(n):
return [Scanner.string() for i in range(n)]
@staticmethod
def int_list_list(n):
return [Scanner.map_int() for i in range(n)]
@staticmethod
def int_cols_list(n):
return [Scanner.int() for i in range(n)]
class Math():
@staticmethod
def gcd(a, b):
if b == 0:
return a
return Math.gcd(b, a % b)
@staticmethod
def lcm(a, b):
return (a * b) // Math.gcd(a, b)
@staticmethod
def divisor(n):
lower, upper = [], []
i = 1
while i * i <= n:
if n % i == 0:
lower.append(i)
if i != n // i:
upper.append(n // i)
i += 1
return lower + upper[::-1]
@staticmethod
def round_up(a, b):
return -(-a // b)
@staticmethod
def is_prime(n):
if n < 2:
return False
if n == 2:
return True
if n % 2 == 0:
return False
d = int(n ** 0.5) + 1
for i in range(3, d + 1, 2):
if n % i == 0:
return False
return True
@staticmethod
def fact(N):
res = {}
tmp = N
for i in range(2, int(N ** 0.5 + 1) + 1):
cnt = 0
while tmp % i == 0:
cnt += 1
tmp //= i
if cnt > 0:
res[i] = cnt
if tmp != 1:
res[tmp] = 1
if res == {}:
res[N] = 1
return res
def pop_count(x):
x = x - ((x >> 1) & 0x5555555555555555)
x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)
x = (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f
x = x + (x >> 8)
x = x + (x >> 16)
x = x + (x >> 32)
return x & 0x0000007f
MOD = int(1e09) + 7
INF = int(1e15)
def solve():
N, M = Scanner.map_int()
A = Scanner.map_int()
A = [-a for a in A]
heapq.heapify(A)
for _ in range(M):
x = -heapq.heappop(A)
x //= 2
heapq.heappush(A, -x)
print((-sum(A)))
def main():
# sys.setrecursionlimit(1000000)
# sys.stdin = open("sample.txt")
# T = Scanner.int()
# for _ in range(T):
# solve()
# print('YNeos'[not solve()::2])
solve()
if __name__ == "__main__":
main()
| 112
| 141
| 2,411
| 3,063
|
# -*- coding: utf-8 -*-
import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from functools import lru_cache
import bisect
import re
import queue
from decimal import *
class Scanner:
@staticmethod
def int():
return int(sys.stdin.readline().rstrip())
@staticmethod
def string():
return sys.stdin.readline().rstrip()
@staticmethod
def map_int():
return [int(x) for x in Scanner.string().split()]
@staticmethod
def string_list(n):
return [eval(input()) for i in range(n)]
@staticmethod
def int_list_list(n):
return [Scanner.map_int() for i in range(n)]
@staticmethod
def int_cols_list(n):
return [int(eval(input())) for i in range(n)]
class Math:
@staticmethod
def gcd(a, b):
if b == 0:
return a
return Math.gcd(b, a % b)
@staticmethod
def lcm(a, b):
return (a * b) // Math.gcd(a, b)
@staticmethod
def divisor(n):
res = []
i = 1
for i in range(1, int(n**0.5) + 1):
if n % i == 0:
res.append(i)
if i != n // i:
res.append(n // i)
return res
@staticmethod
def round_up(a, b):
return -(-a // b)
@staticmethod
def is_prime(n):
if n < 2:
return False
if n == 2:
return True
if n % 2 == 0:
return False
d = int(n**0.5) + 1
for i in range(3, d + 1, 2):
if n % i == 0:
return False
return True
def pop_count(x):
x = x - ((x >> 1) & 0x5555555555555555)
x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)
x = (x + (x >> 4)) & 0x0F0F0F0F0F0F0F0F
x = x + (x >> 8)
x = x + (x >> 16)
x = x + (x >> 32)
return x & 0x0000007F
MOD = int(1e09) + 7
INF = int(1e15)
def main():
# sys.stdin = open("sample.txt")
N, M = Scanner.map_int()
A = [-a for a in Scanner.map_int()]
heapq.heapify(A)
for _ in range(M):
a = heapq.heappop(A)
a = -(-a // 2)
heapq.heappush(A, a)
print((-sum(A)))
if __name__ == "__main__":
main()
|
# -*- coding: utf-8 -*-
import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from collections import deque
from functools import lru_cache
import bisect
import re
import queue
import decimal
class Scanner:
@staticmethod
def int():
return int(sys.stdin.readline().rstrip())
@staticmethod
def string():
return sys.stdin.readline().rstrip()
@staticmethod
def map_int():
return [int(x) for x in Scanner.string().split()]
@staticmethod
def string_list(n):
return [Scanner.string() for i in range(n)]
@staticmethod
def int_list_list(n):
return [Scanner.map_int() for i in range(n)]
@staticmethod
def int_cols_list(n):
return [Scanner.int() for i in range(n)]
class Math:
@staticmethod
def gcd(a, b):
if b == 0:
return a
return Math.gcd(b, a % b)
@staticmethod
def lcm(a, b):
return (a * b) // Math.gcd(a, b)
@staticmethod
def divisor(n):
lower, upper = [], []
i = 1
while i * i <= n:
if n % i == 0:
lower.append(i)
if i != n // i:
upper.append(n // i)
i += 1
return lower + upper[::-1]
@staticmethod
def round_up(a, b):
return -(-a // b)
@staticmethod
def is_prime(n):
if n < 2:
return False
if n == 2:
return True
if n % 2 == 0:
return False
d = int(n**0.5) + 1
for i in range(3, d + 1, 2):
if n % i == 0:
return False
return True
@staticmethod
def fact(N):
res = {}
tmp = N
for i in range(2, int(N**0.5 + 1) + 1):
cnt = 0
while tmp % i == 0:
cnt += 1
tmp //= i
if cnt > 0:
res[i] = cnt
if tmp != 1:
res[tmp] = 1
if res == {}:
res[N] = 1
return res
def pop_count(x):
x = x - ((x >> 1) & 0x5555555555555555)
x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)
x = (x + (x >> 4)) & 0x0F0F0F0F0F0F0F0F
x = x + (x >> 8)
x = x + (x >> 16)
x = x + (x >> 32)
return x & 0x0000007F
MOD = int(1e09) + 7
INF = int(1e15)
def solve():
N, M = Scanner.map_int()
A = Scanner.map_int()
A = [-a for a in A]
heapq.heapify(A)
for _ in range(M):
x = -heapq.heappop(A)
x //= 2
heapq.heappush(A, -x)
print((-sum(A)))
def main():
# sys.setrecursionlimit(1000000)
# sys.stdin = open("sample.txt")
# T = Scanner.int()
# for _ in range(T):
# solve()
# print('YNeos'[not solve()::2])
solve()
if __name__ == "__main__":
main()
| false
| 20.567376
|
[
"+from collections import deque",
"-from decimal import *",
"+import decimal",
"- return [eval(input()) for i in range(n)]",
"+ return [Scanner.string() for i in range(n)]",
"- return [int(eval(input())) for i in range(n)]",
"+ return [Scanner.int() for i in range(n)]",
"- res = []",
"+ lower, upper = [], []",
"- for i in range(1, int(n**0.5) + 1):",
"+ while i * i <= n:",
"- res.append(i)",
"+ lower.append(i)",
"- res.append(n // i)",
"- return res",
"+ upper.append(n // i)",
"+ i += 1",
"+ return lower + upper[::-1]",
"+ @staticmethod",
"+ def fact(N):",
"+ res = {}",
"+ tmp = N",
"+ for i in range(2, int(N**0.5 + 1) + 1):",
"+ cnt = 0",
"+ while tmp % i == 0:",
"+ cnt += 1",
"+ tmp //= i",
"+ if cnt > 0:",
"+ res[i] = cnt",
"+ if tmp != 1:",
"+ res[tmp] = 1",
"+ if res == {}:",
"+ res[N] = 1",
"+ return res",
"+",
"-def main():",
"- # sys.stdin = open(\"sample.txt\")",
"+def solve():",
"- A = [-a for a in Scanner.map_int()]",
"+ A = Scanner.map_int()",
"+ A = [-a for a in A]",
"- a = heapq.heappop(A)",
"- a = -(-a // 2)",
"- heapq.heappush(A, a)",
"+ x = -heapq.heappop(A)",
"+ x //= 2",
"+ heapq.heappush(A, -x)",
"+",
"+",
"+def main():",
"+ # sys.setrecursionlimit(1000000)",
"+ # sys.stdin = open(\"sample.txt\")",
"+ # T = Scanner.int()",
"+ # for _ in range(T):",
"+ # solve()",
"+ # print('YNeos'[not solve()::2])",
"+ solve()"
] | false
| 0.037554
| 0.059254
| 0.63379
|
[
"s896691498",
"s237237338"
] |
u671211357
|
p04001
|
python
|
s140845265
|
s504080404
| 202
| 30
| 39,920
| 3,064
|
Accepted
|
Accepted
| 85.15
|
S=list(eval(input()))
ans=0
for i in range(2**(len(S)-1)):
kari=[""]*(len(S)-1)
for j in range(len(S)-1):
if ((i>>j)&1):
kari[j]="+"
hako=[]
kotae=0
kasu=0
gomi=0
for j in range(len(kari)+len(S)):
if j%2==0:
hako.append(S[kasu])
kasu+=1
else:
hako.append(kari[gomi])
gomi+=1
#print(hako)
hako="".join(hako)
#hako=hako.replace(",","")
#print(hako)
kotae=eval(hako)
ans+=kotae
print(ans)
|
S=list(eval(input()))
ans=0
for i in range(2**(len(S)-1)):
kari=[""]*(len(S)-1)
for j in range(len(S)-1):
if ((i>>j)&1):
kari[j]="+"
hako=[]
kasu=0
gomi=0
for j in range(len(kari)+len(S)):
if j%2==0:
hako.append(S[kasu])
kasu+=1
else:
hako.append(kari[gomi])
gomi+=1
#print(hako)
hako="".join(hako)
#hako=hako.replace(",","")
#print(hako)
ans+=eval(hako)
print(ans)
| 25
| 23
| 539
| 509
|
S = list(eval(input()))
ans = 0
for i in range(2 ** (len(S) - 1)):
kari = [""] * (len(S) - 1)
for j in range(len(S) - 1):
if (i >> j) & 1:
kari[j] = "+"
hako = []
kotae = 0
kasu = 0
gomi = 0
for j in range(len(kari) + len(S)):
if j % 2 == 0:
hako.append(S[kasu])
kasu += 1
else:
hako.append(kari[gomi])
gomi += 1
# print(hako)
hako = "".join(hako)
# hako=hako.replace(",","")
# print(hako)
kotae = eval(hako)
ans += kotae
print(ans)
|
S = list(eval(input()))
ans = 0
for i in range(2 ** (len(S) - 1)):
kari = [""] * (len(S) - 1)
for j in range(len(S) - 1):
if (i >> j) & 1:
kari[j] = "+"
hako = []
kasu = 0
gomi = 0
for j in range(len(kari) + len(S)):
if j % 2 == 0:
hako.append(S[kasu])
kasu += 1
else:
hako.append(kari[gomi])
gomi += 1
# print(hako)
hako = "".join(hako)
# hako=hako.replace(",","")
# print(hako)
ans += eval(hako)
print(ans)
| false
| 8
|
[
"- kotae = 0",
"- kotae = eval(hako)",
"- ans += kotae",
"+ ans += eval(hako)"
] | false
| 0.113077
| 0.039361
| 2.8728
|
[
"s140845265",
"s504080404"
] |
u463848480
|
p03448
|
python
|
s891804260
|
s082438747
| 34
| 30
| 3,064
| 3,064
|
Accepted
|
Accepted
| 11.76
|
def main():
A = int(input().strip())
B = int(input().strip())
C = int(input().strip())
X = int(input().strip())
if 500 > X: A = 0
if 100 > X: B = 0
count = 0
for ai in [x*500 for x in range(A+1)]:
Xa = X - ai
for bi in [x*100 for x in range(B+1)]:
Xb = Xa - bi
for ci in [x*50 for x in range(C+1)]:
Xc = Xb - ci
if Xc == 0:
count += 1
return count
if __name__ == '__main__':
print((main()))
|
def main():
A = int(input().strip())
B = int(input().strip())
C = int(input().strip())
X = int(input().strip())
count = 0
for ai in [x*500 for x in range(A+1)]:
Xa = X - ai
if Xa < 0: break
for bi in [x*100 for x in range(B+1)]:
Xb = Xa - bi
if Xb < 0: break
for ci in [x*50 for x in range(C+1)]:
Xc = Xb - ci
if Xc < 0: break
if Xc == 0:
count += 1
return count
if __name__ == '__main__':
print((main()))
| 20
| 22
| 544
| 590
|
def main():
A = int(input().strip())
B = int(input().strip())
C = int(input().strip())
X = int(input().strip())
if 500 > X:
A = 0
if 100 > X:
B = 0
count = 0
for ai in [x * 500 for x in range(A + 1)]:
Xa = X - ai
for bi in [x * 100 for x in range(B + 1)]:
Xb = Xa - bi
for ci in [x * 50 for x in range(C + 1)]:
Xc = Xb - ci
if Xc == 0:
count += 1
return count
if __name__ == "__main__":
print((main()))
|
def main():
A = int(input().strip())
B = int(input().strip())
C = int(input().strip())
X = int(input().strip())
count = 0
for ai in [x * 500 for x in range(A + 1)]:
Xa = X - ai
if Xa < 0:
break
for bi in [x * 100 for x in range(B + 1)]:
Xb = Xa - bi
if Xb < 0:
break
for ci in [x * 50 for x in range(C + 1)]:
Xc = Xb - ci
if Xc < 0:
break
if Xc == 0:
count += 1
return count
if __name__ == "__main__":
print((main()))
| false
| 9.090909
|
[
"- if 500 > X:",
"- A = 0",
"- if 100 > X:",
"- B = 0",
"+ if Xa < 0:",
"+ break",
"+ if Xb < 0:",
"+ break",
"+ if Xc < 0:",
"+ break"
] | false
| 0.062026
| 0.045603
| 1.36013
|
[
"s891804260",
"s082438747"
] |
u608088992
|
p03197
|
python
|
s195008840
|
s168220208
| 189
| 63
| 3,872
| 3,316
|
Accepted
|
Accepted
| 66.67
|
N = int(eval(input()))
A = [int(eval(input()))%2 for n in range(N)]
for i in range(N):
if A[i] == 1:
print("first")
break
else: print("second")
|
import sys
from collections import deque
def solve():
input = sys.stdin.readline
N = int(eval(input()))
first = False
for _ in range(N):
a = int(eval(input()))
if a % 2 == 1: first = True
if first: print("first")
else: print("second")
return 0
if __name__ == "__main__":
solve()
| 8
| 18
| 161
| 351
|
N = int(eval(input()))
A = [int(eval(input())) % 2 for n in range(N)]
for i in range(N):
if A[i] == 1:
print("first")
break
else:
print("second")
|
import sys
from collections import deque
def solve():
input = sys.stdin.readline
N = int(eval(input()))
first = False
for _ in range(N):
a = int(eval(input()))
if a % 2 == 1:
first = True
if first:
print("first")
else:
print("second")
return 0
if __name__ == "__main__":
solve()
| false
| 55.555556
|
[
"-N = int(eval(input()))",
"-A = [int(eval(input())) % 2 for n in range(N)]",
"-for i in range(N):",
"- if A[i] == 1:",
"+import sys",
"+from collections import deque",
"+",
"+",
"+def solve():",
"+ input = sys.stdin.readline",
"+ N = int(eval(input()))",
"+ first = False",
"+ for _ in range(N):",
"+ a = int(eval(input()))",
"+ if a % 2 == 1:",
"+ first = True",
"+ if first:",
"- break",
"-else:",
"- print(\"second\")",
"+ else:",
"+ print(\"second\")",
"+ return 0",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ solve()"
] | false
| 0.035205
| 0.035073
| 1.003775
|
[
"s195008840",
"s168220208"
] |
u645487439
|
p02702
|
python
|
s186675099
|
s705913698
| 122
| 108
| 9,344
| 9,212
|
Accepted
|
Accepted
| 11.48
|
s = input()[::-1]
d = 1
num = 0
ans = 0
mod_list = [0] * 2019
mod_list[0] = 1
for char in s:
num += int(char) * d
num %= 2019
d *= 10
d %= 2019
mod_list[num % 2019] += 1
for i in range(2019):
ans += mod_list[i] * (mod_list[i] - 1) //2
print(ans)
|
s = input()[::-1]
d = 1
num = 0
ans = 0
mod_list = [0] * 2019
mod_list[0] = 1
for char in s:
num += int(char) * d
mod_list[num % 2019] += 1
d *= 10
d %= 2019
for i in range(2019):
ans += mod_list[i] * (mod_list[i] - 1) //2
print(ans)
| 18
| 17
| 290
| 273
|
s = input()[::-1]
d = 1
num = 0
ans = 0
mod_list = [0] * 2019
mod_list[0] = 1
for char in s:
num += int(char) * d
num %= 2019
d *= 10
d %= 2019
mod_list[num % 2019] += 1
for i in range(2019):
ans += mod_list[i] * (mod_list[i] - 1) // 2
print(ans)
|
s = input()[::-1]
d = 1
num = 0
ans = 0
mod_list = [0] * 2019
mod_list[0] = 1
for char in s:
num += int(char) * d
mod_list[num % 2019] += 1
d *= 10
d %= 2019
for i in range(2019):
ans += mod_list[i] * (mod_list[i] - 1) // 2
print(ans)
| false
| 5.555556
|
[
"- num %= 2019",
"+ mod_list[num % 2019] += 1",
"- mod_list[num % 2019] += 1"
] | false
| 0.036205
| 0.036803
| 0.98376
|
[
"s186675099",
"s705913698"
] |
u346812984
|
p03557
|
python
|
s168986526
|
s847677055
| 323
| 290
| 23,360
| 22,720
|
Accepted
|
Accepted
| 10.22
|
import bisect
N = int(eval(input()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
A.sort()
B.sort()
C.sort()
ans = 0
for b in B:
na = bisect.bisect_left(A, b)
nb = N - bisect.bisect_right(C, b)
ans += na * nb
print(ans)
|
import bisect
import sys
sys.setrecursionlimit(10 ** 6)
INF = float("inf")
MOD = 10 ** 9 + 7
def input():
return sys.stdin.readline().strip()
def main():
N = int(eval(input()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
A.sort()
B.sort()
C.sort()
ans = 0
for b in B:
upper = bisect.bisect_left(A, b)
bottom = N - bisect.bisect_right(C, b)
ans += upper * bottom
print(ans)
if __name__ == "__main__":
main()
| 17
| 32
| 308
| 577
|
import bisect
N = int(eval(input()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
A.sort()
B.sort()
C.sort()
ans = 0
for b in B:
na = bisect.bisect_left(A, b)
nb = N - bisect.bisect_right(C, b)
ans += na * nb
print(ans)
|
import bisect
import sys
sys.setrecursionlimit(10**6)
INF = float("inf")
MOD = 10**9 + 7
def input():
return sys.stdin.readline().strip()
def main():
N = int(eval(input()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
A.sort()
B.sort()
C.sort()
ans = 0
for b in B:
upper = bisect.bisect_left(A, b)
bottom = N - bisect.bisect_right(C, b)
ans += upper * bottom
print(ans)
if __name__ == "__main__":
main()
| false
| 46.875
|
[
"+import sys",
"-N = int(eval(input()))",
"-A = list(map(int, input().split()))",
"-B = list(map(int, input().split()))",
"-C = list(map(int, input().split()))",
"-A.sort()",
"-B.sort()",
"-C.sort()",
"-ans = 0",
"-for b in B:",
"- na = bisect.bisect_left(A, b)",
"- nb = N - bisect.bisect_right(C, b)",
"- ans += na * nb",
"-print(ans)",
"+sys.setrecursionlimit(10**6)",
"+INF = float(\"inf\")",
"+MOD = 10**9 + 7",
"+",
"+",
"+def input():",
"+ return sys.stdin.readline().strip()",
"+",
"+",
"+def main():",
"+ N = int(eval(input()))",
"+ A = list(map(int, input().split()))",
"+ B = list(map(int, input().split()))",
"+ C = list(map(int, input().split()))",
"+ A.sort()",
"+ B.sort()",
"+ C.sort()",
"+ ans = 0",
"+ for b in B:",
"+ upper = bisect.bisect_left(A, b)",
"+ bottom = N - bisect.bisect_right(C, b)",
"+ ans += upper * bottom",
"+ print(ans)",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false
| 0.048399
| 0.049655
| 0.974704
|
[
"s168986526",
"s847677055"
] |
u408260374
|
p01130
|
python
|
s335432045
|
s294464813
| 37,530
| 22,170
| 8,028
| 8,036
|
Accepted
|
Accepted
| 40.93
|
while True:
N, M, s, g1, g2 = list(map(int, input().split()))
if N == M == s == g1 == g2 == 0:
break
s, g1, g2 = s - 1, g1 - 1, g2 - 1
INF = 10 ** 5
D = [[INF] * N for _ in range(N)]
for i in range(N):
D[i][i] = 0
for _ in range(M):
b1, b2, c = list(map(int, input().split()))
b1, b2 = b1 - 1, b2 - 1
D[b1][b2] = c
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])
print((min(D[s][i] + D[i][g1] + D[i][g2] for i in range(N))))
|
while True:
N, M, s, g1, g2 = list(map(int, input().split()))
if N == M == s == g1 == g2 == 0:
break
s, g1, g2 = s - 1, g1 - 1, g2 - 1
INF = 10 ** 5
D = [[INF] * N for _ in range(N)]
for i in range(N):
D[i][i] = 0
for _ in range(M):
b1, b2, c = list(map(int, input().split()))
b1, b2 = b1 - 1, b2 - 1
D[b1][b2] = c
for k in range(N):
for i in range(N):
for j in range(N):
if D[i][j] > D[i][k] + D[k][j]:
D[i][j] = D[i][k] + D[k][j]
print((min(D[s][i] + D[i][g1] + D[i][g2] for i in range(N))))
| 18
| 19
| 590
| 629
|
while True:
N, M, s, g1, g2 = list(map(int, input().split()))
if N == M == s == g1 == g2 == 0:
break
s, g1, g2 = s - 1, g1 - 1, g2 - 1
INF = 10**5
D = [[INF] * N for _ in range(N)]
for i in range(N):
D[i][i] = 0
for _ in range(M):
b1, b2, c = list(map(int, input().split()))
b1, b2 = b1 - 1, b2 - 1
D[b1][b2] = c
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])
print((min(D[s][i] + D[i][g1] + D[i][g2] for i in range(N))))
|
while True:
N, M, s, g1, g2 = list(map(int, input().split()))
if N == M == s == g1 == g2 == 0:
break
s, g1, g2 = s - 1, g1 - 1, g2 - 1
INF = 10**5
D = [[INF] * N for _ in range(N)]
for i in range(N):
D[i][i] = 0
for _ in range(M):
b1, b2, c = list(map(int, input().split()))
b1, b2 = b1 - 1, b2 - 1
D[b1][b2] = c
for k in range(N):
for i in range(N):
for j in range(N):
if D[i][j] > D[i][k] + D[k][j]:
D[i][j] = D[i][k] + D[k][j]
print((min(D[s][i] + D[i][g1] + D[i][g2] for i in range(N))))
| false
| 5.263158
|
[
"- D[i][j] = min(D[i][j], D[i][k] + D[k][j])",
"+ if D[i][j] > D[i][k] + D[k][j]:",
"+ D[i][j] = D[i][k] + D[k][j]"
] | false
| 0.045132
| 0.108521
| 0.415882
|
[
"s335432045",
"s294464813"
] |
u622045059
|
p04012
|
python
|
s153869551
|
s304231642
| 171
| 20
| 38,640
| 3,316
|
Accepted
|
Accepted
| 88.3
|
W = eval(input())
cnt = {}
for w in W:
if w not in list(cnt.keys()):
cnt[w] = 1
else:
cnt[w] += 1
ans = 'Yes'
for v in list(cnt.values()):
if v % 2 == 1:
ans = 'No'
break
print(ans)
|
import collections
w = eval(input())
c = collections.Counter(w)
ans = 'Yes'
for v in list(c.values()):
if v % 2 == 1:
ans = 'No'
break
print(ans)
| 17
| 13
| 228
| 170
|
W = eval(input())
cnt = {}
for w in W:
if w not in list(cnt.keys()):
cnt[w] = 1
else:
cnt[w] += 1
ans = "Yes"
for v in list(cnt.values()):
if v % 2 == 1:
ans = "No"
break
print(ans)
|
import collections
w = eval(input())
c = collections.Counter(w)
ans = "Yes"
for v in list(c.values()):
if v % 2 == 1:
ans = "No"
break
print(ans)
| false
| 23.529412
|
[
"-W = eval(input())",
"-cnt = {}",
"-for w in W:",
"- if w not in list(cnt.keys()):",
"- cnt[w] = 1",
"- else:",
"- cnt[w] += 1",
"+import collections",
"+",
"+w = eval(input())",
"+c = collections.Counter(w)",
"-for v in list(cnt.values()):",
"+for v in list(c.values()):"
] | false
| 0.047249
| 0.04736
| 0.997656
|
[
"s153869551",
"s304231642"
] |
u385244248
|
p02768
|
python
|
s874806135
|
s536636495
| 478
| 359
| 77,656
| 13,116
|
Accepted
|
Accepted
| 24.9
|
import sys
import math
import fractions
import itertools
from collections import deque
import copy
import bisect
MOD = 10 ** 9 + 7
INF = 10 ** 18 + 7
input = lambda: sys.stdin.readline().strip()
def inv_mod(a, N):
"""
Fermatの小定理より(Nが素数のときしか使えない)
aの逆元 ax = 1 (mod N)を満たすx = a^(N-2) mod Nを返す。
O(log N)
"""
def bpm(x, y, N):
"""
Bisection power method : 二分累乗法
O(log y)でx^(y) mod N を求める。
"""
ans = 1
x %= MOD
digit = int((math.log(y, 2) // 1 + 1)) # yの２進数表示の桁数
for i in range(digit):
if (y >> i) & 1 == 1:
ans *= x
ans %= MOD
x **= 2
x %= MOD
return ans
return bpm(a, N - 2, N)
def bpm(x, y, N):
"""
Bisection power method : 二分累乗法
O(log y)でx^(y) mod N を求める。
"""
ans = 1
x %= MOD
digit = int((math.log(y, 2) // 1 + 1)) # yの２進数表示の桁数
for i in range(digit):
if (y >> i) & 1 == 1:
ans *= x
ans %= MOD
x **= 2
x %= MOD
return ans
n, a, b = list(map(int, input().split()))
nCa = 1
nCb = 1
inv_list = []
for i in range(max(a, b)):
inv_list.append(inv_mod(i + 1, MOD))
for i in range(a):
nCa *= inv_list[i]
nCa %= MOD
nCa *= n - i
nCa %= MOD
for i in range(b):
nCb *= inv_list[i]
nCb %= MOD
nCb *= n - i
nCb %= MOD
print(((bpm(2, n, MOD) - 1 - nCa - nCb) % MOD))
|
import sys
import math
import fractions
import itertools
from collections import deque
import copy
import bisect
MOD = 10 ** 9 + 7
INF = 10 ** 18 + 7
input = lambda: sys.stdin.readline().strip()
def inv_mod(a, N):
"""
Fermatの小定理より(Nが素数のときしか使えない)
aの逆元 ax = 1 (mod N)を満たすx = a^(N-2) mod Nを返す。
O(log N)
"""
def bpm(x, y, N):
"""
Bisection power method : 二分累乗法
O(log y)でx^(y) mod N を求める。
"""
ans = 1
x %= MOD
digit = int((math.log(y, 2) // 1 + 1)) # yの２進数表示の桁数
for i in range(digit):
if (y >> i) & 1 == 1:
ans *= x
ans %= MOD
x **= 2
x %= MOD
return ans
return bpm(a, N - 2, N)
def bpm(x, y, N):
"""
Bisection power method : 二分累乗法
O(log y)でx^(y) mod N を求める。
"""
ans = 1
x %= MOD
digit = int((math.log(y, 2) // 1 + 1)) # yの２進数表示の桁数
for i in range(digit):
if (y >> i) & 1 == 1:
ans *= x
ans %= MOD
x **= 2
x %= MOD
return ans
n, a, b = list(map(int, input().split()))
nCa = 1
nCb = 1
inv_list = [1] # 0で割るというのは定義されないので無視。
for i in range(max(a, b)):
inv_list.append(int(MOD - inv_list[(MOD % (i + 2)) - 1] * (MOD // (i + 2)) % MOD))
for i in range(a):
nCa *= inv_list[i]
nCa %= MOD
nCa *= n - i
nCa %= MOD
for i in range(b):
nCb *= inv_list[i]
nCb %= MOD
nCb *= n - i
nCb %= MOD
print(((bpm(2, n, MOD) - 1 - nCa - nCb) % MOD))
| 79
| 78
| 1,529
| 1,598
|
import sys
import math
import fractions
import itertools
from collections import deque
import copy
import bisect
MOD = 10**9 + 7
INF = 10**18 + 7
input = lambda: sys.stdin.readline().strip()
def inv_mod(a, N):
"""
Fermatの小定理より(Nが素数のときしか使えない)
aの逆元 ax = 1 (mod N)を満たすx = a^(N-2) mod Nを返す。
O(log N)
"""
def bpm(x, y, N):
"""
Bisection power method : 二分累乗法
O(log y)でx^(y) mod N を求める。
"""
ans = 1
x %= MOD
digit = int((math.log(y, 2) // 1 + 1)) # yの２進数表示の桁数
for i in range(digit):
if (y >> i) & 1 == 1:
ans *= x
ans %= MOD
x **= 2
x %= MOD
return ans
return bpm(a, N - 2, N)
def bpm(x, y, N):
"""
Bisection power method : 二分累乗法
O(log y)でx^(y) mod N を求める。
"""
ans = 1
x %= MOD
digit = int((math.log(y, 2) // 1 + 1)) # yの２進数表示の桁数
for i in range(digit):
if (y >> i) & 1 == 1:
ans *= x
ans %= MOD
x **= 2
x %= MOD
return ans
n, a, b = list(map(int, input().split()))
nCa = 1
nCb = 1
inv_list = []
for i in range(max(a, b)):
inv_list.append(inv_mod(i + 1, MOD))
for i in range(a):
nCa *= inv_list[i]
nCa %= MOD
nCa *= n - i
nCa %= MOD
for i in range(b):
nCb *= inv_list[i]
nCb %= MOD
nCb *= n - i
nCb %= MOD
print(((bpm(2, n, MOD) - 1 - nCa - nCb) % MOD))
|
import sys
import math
import fractions
import itertools
from collections import deque
import copy
import bisect
MOD = 10**9 + 7
INF = 10**18 + 7
input = lambda: sys.stdin.readline().strip()
def inv_mod(a, N):
"""
Fermatの小定理より(Nが素数のときしか使えない)
aの逆元 ax = 1 (mod N)を満たすx = a^(N-2) mod Nを返す。
O(log N)
"""
def bpm(x, y, N):
"""
Bisection power method : 二分累乗法
O(log y)でx^(y) mod N を求める。
"""
ans = 1
x %= MOD
digit = int((math.log(y, 2) // 1 + 1)) # yの２進数表示の桁数
for i in range(digit):
if (y >> i) & 1 == 1:
ans *= x
ans %= MOD
x **= 2
x %= MOD
return ans
return bpm(a, N - 2, N)
def bpm(x, y, N):
"""
Bisection power method : 二分累乗法
O(log y)でx^(y) mod N を求める。
"""
ans = 1
x %= MOD
digit = int((math.log(y, 2) // 1 + 1)) # yの２進数表示の桁数
for i in range(digit):
if (y >> i) & 1 == 1:
ans *= x
ans %= MOD
x **= 2
x %= MOD
return ans
n, a, b = list(map(int, input().split()))
nCa = 1
nCb = 1
inv_list = [1] # 0で割るというのは定義されないので無視。
for i in range(max(a, b)):
inv_list.append(int(MOD - inv_list[(MOD % (i + 2)) - 1] * (MOD // (i + 2)) % MOD))
for i in range(a):
nCa *= inv_list[i]
nCa %= MOD
nCa *= n - i
nCa %= MOD
for i in range(b):
nCb *= inv_list[i]
nCb %= MOD
nCb *= n - i
nCb %= MOD
print(((bpm(2, n, MOD) - 1 - nCa - nCb) % MOD))
| false
| 1.265823
|
[
"-inv_list = []",
"+inv_list = [1] # 0で割るというのは定義されないので無視。",
"- inv_list.append(inv_mod(i + 1, MOD))",
"+ inv_list.append(int(MOD - inv_list[(MOD % (i + 2)) - 1] * (MOD // (i + 2)) % MOD))"
] | false
| 1.208756
| 0.262719
| 4.600955
|
[
"s874806135",
"s536636495"
] |
u217627525
|
p03631
|
python
|
s829414467
|
s804031592
| 19
| 17
| 2,940
| 2,940
|
Accepted
|
Accepted
| 10.53
|
n=int(eval(input()))
if n//100==n%10:
print("Yes")
else:
print("No")
|
n=eval(input())
if n[0]==n[2]:
print("Yes")
else:
print("No")
| 5
| 5
| 74
| 67
|
n = int(eval(input()))
if n // 100 == n % 10:
print("Yes")
else:
print("No")
|
n = eval(input())
if n[0] == n[2]:
print("Yes")
else:
print("No")
| false
| 0
|
[
"-n = int(eval(input()))",
"-if n // 100 == n % 10:",
"+n = eval(input())",
"+if n[0] == n[2]:"
] | false
| 0.043273
| 0.045582
| 0.949345
|
[
"s829414467",
"s804031592"
] |
u221264296
|
p02773
|
python
|
s183129570
|
s135269020
| 980
| 707
| 55,316
| 32,096
|
Accepted
|
Accepted
| 27.86
|
n=int(eval(input()))
mx = 0
t=[]
d={}
for i in range(n):
s=eval(input())
t+=[s]
d[s] = d.get(s,0)+1
mx = max(mx,d[s])
v=[]
d2={}
for s in t:
if(d[s]==mx and d2.get(s,0)==0):
v+=[s]
d2[s] = d2.get(s,0)+1
v.sort()
for s in v:
print(s)
|
n = int(eval(input()))
d = {}
for i in range(n):
s = eval(input())
d[s] = d.get(s,0)+1
m = max(d[i] for i in d)
for s in sorted(d):
if d[s]==m:
print(s)
| 20
| 9
| 254
| 158
|
n = int(eval(input()))
mx = 0
t = []
d = {}
for i in range(n):
s = eval(input())
t += [s]
d[s] = d.get(s, 0) + 1
mx = max(mx, d[s])
v = []
d2 = {}
for s in t:
if d[s] == mx and d2.get(s, 0) == 0:
v += [s]
d2[s] = d2.get(s, 0) + 1
v.sort()
for s in v:
print(s)
|
n = int(eval(input()))
d = {}
for i in range(n):
s = eval(input())
d[s] = d.get(s, 0) + 1
m = max(d[i] for i in d)
for s in sorted(d):
if d[s] == m:
print(s)
| false
| 55
|
[
"-mx = 0",
"-t = []",
"- t += [s]",
"- mx = max(mx, d[s])",
"-v = []",
"-d2 = {}",
"-for s in t:",
"- if d[s] == mx and d2.get(s, 0) == 0:",
"- v += [s]",
"- d2[s] = d2.get(s, 0) + 1",
"-v.sort()",
"-for s in v:",
"- print(s)",
"+m = max(d[i] for i in d)",
"+for s in sorted(d):",
"+ if d[s] == m:",
"+ print(s)"
] | false
| 0.047703
| 0.048291
| 0.98783
|
[
"s183129570",
"s135269020"
] |
u237493274
|
p02936
|
python
|
s616977234
|
s213990498
| 1,890
| 1,255
| 124,236
| 124,236
|
Accepted
|
Accepted
| 33.6
|
N,Q = list(map(int,input().split()))
AB = [[int(x) for x in input().split()] for _ in range(N-1)]
PX = [[int(x) for x in input().split()] for _ in range(Q)]
graph = [[] for _ in range(N+1)]
for a,b in AB:
graph[a].append(b)
graph[b].append(a)
value = [0] * (N+1)
for p,x in PX:
value[p] += x
q = [(1,0)]
while q:
x,parent = q.pop()
value[x] += value[parent]
for y in graph[x]:
if y == parent:
continue
q.append((y,x))
answer = ' '.join(map(str,value[1:]))
print(answer)
|
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
N,Q = list(map(int,input().split()))
AB = [[int(x) for x in input().split()] for _ in range(N-1)]
PX = [[int(x) for x in input().split()] for _ in range(Q)]
graph = [[] for _ in range(N+1)]
for a,b in AB:
graph[a].append(b)
graph[b].append(a)
value = [0] * (N+1)
for p,x in PX:
value[p] += x
q = [(1,0)]
while q:
x,parent = q.pop()
value[x] += value[parent]
for y in graph[x]:
if y == parent:
continue
q.append((y,x))
answer = ' '.join(map(str,value[1:]))
print(answer)
| 24
| 28
| 547
| 621
|
N, Q = list(map(int, input().split()))
AB = [[int(x) for x in input().split()] for _ in range(N - 1)]
PX = [[int(x) for x in input().split()] for _ in range(Q)]
graph = [[] for _ in range(N + 1)]
for a, b in AB:
graph[a].append(b)
graph[b].append(a)
value = [0] * (N + 1)
for p, x in PX:
value[p] += x
q = [(1, 0)]
while q:
x, parent = q.pop()
value[x] += value[parent]
for y in graph[x]:
if y == parent:
continue
q.append((y, x))
answer = " ".join(map(str, value[1:]))
print(answer)
|
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
N, Q = list(map(int, input().split()))
AB = [[int(x) for x in input().split()] for _ in range(N - 1)]
PX = [[int(x) for x in input().split()] for _ in range(Q)]
graph = [[] for _ in range(N + 1)]
for a, b in AB:
graph[a].append(b)
graph[b].append(a)
value = [0] * (N + 1)
for p, x in PX:
value[p] += x
q = [(1, 0)]
while q:
x, parent = q.pop()
value[x] += value[parent]
for y in graph[x]:
if y == parent:
continue
q.append((y, x))
answer = " ".join(map(str, value[1:]))
print(answer)
| false
| 14.285714
|
[
"+import sys",
"+",
"+input = sys.stdin.readline",
"+sys.setrecursionlimit(10**7)"
] | false
| 0.040204
| 0.035923
| 1.119144
|
[
"s616977234",
"s213990498"
] |
u760569096
|
p03295
|
python
|
s753262700
|
s772170597
| 1,451
| 515
| 219,820
| 222,220
|
Accepted
|
Accepted
| 64.51
|
n,m = list(map(int, input().split()))
g = [[n] for i in range(n)]
for i in range(m):
a,b = list(map(int, input().split()))
g[a-1].append(b-1)
k = 0
ans=0
while k <=n-1:
e = n
for i in g[k:]:
e = min(e,min(i))
if e==n:
break
ans+=1
k = e
print(ans)
|
n,m = list(map(int, input().split()))
t = [[n] for i in range(n)]
for i in range(m):
a,b = list(map(int, input().split()))
t[a-1].append(b-1)
g = []
for i in t:
g.append(sorted(i))
k = 0
ans=0
while k <=n-1:
e = n
for i in g[k:]:
e = min(e,i[0])
if e==n:
break
ans+=1
k = e
print(ans)
| 16
| 19
| 272
| 314
|
n, m = list(map(int, input().split()))
g = [[n] for i in range(n)]
for i in range(m):
a, b = list(map(int, input().split()))
g[a - 1].append(b - 1)
k = 0
ans = 0
while k <= n - 1:
e = n
for i in g[k:]:
e = min(e, min(i))
if e == n:
break
ans += 1
k = e
print(ans)
|
n, m = list(map(int, input().split()))
t = [[n] for i in range(n)]
for i in range(m):
a, b = list(map(int, input().split()))
t[a - 1].append(b - 1)
g = []
for i in t:
g.append(sorted(i))
k = 0
ans = 0
while k <= n - 1:
e = n
for i in g[k:]:
e = min(e, i[0])
if e == n:
break
ans += 1
k = e
print(ans)
| false
| 15.789474
|
[
"-g = [[n] for i in range(n)]",
"+t = [[n] for i in range(n)]",
"- g[a - 1].append(b - 1)",
"+ t[a - 1].append(b - 1)",
"+g = []",
"+for i in t:",
"+ g.append(sorted(i))",
"- e = min(e, min(i))",
"+ e = min(e, i[0])"
] | false
| 0.182618
| 0.035094
| 5.203698
|
[
"s753262700",
"s772170597"
] |
u190178779
|
p03829
|
python
|
s745335012
|
s932153856
| 113
| 81
| 20,352
| 19,980
|
Accepted
|
Accepted
| 28.32
|
import sys
N,A,B = list(map(int,input().split()))
array = list(map(int,input().split()))
if not ( 2 <= N <= 10**5 and 1 <= A <= 10**9 and 1 <= B <= 10**9 ): sys.exit()
for I in range(len(array)):
if not ( 1 <= array[I] <= 10**9 ): sys.exit()
if array[I] != array[-1]:
if not ( array[I] < array[I+1] ): sys.exit()
cost = 0
for J in range(len(array)):
if array[J] != array[-1]:
walk_cost = (array[J+1] - array[J])*A
if walk_cost < B:
cost += walk_cost
else:
cost += B
print(cost)
|
import sys
N,A,B = list(map(int,input().split()))
array = list(map(int,input().split()))
cost = 0
for J in range(len(array)-1):
walk_cost = (array[J+1] - array[J])*A
if walk_cost < B:
cost += walk_cost
else:
cost += B
print(cost)
| 19
| 12
| 559
| 284
|
import sys
N, A, B = list(map(int, input().split()))
array = list(map(int, input().split()))
if not (2 <= N <= 10**5 and 1 <= A <= 10**9 and 1 <= B <= 10**9):
sys.exit()
for I in range(len(array)):
if not (1 <= array[I] <= 10**9):
sys.exit()
if array[I] != array[-1]:
if not (array[I] < array[I + 1]):
sys.exit()
cost = 0
for J in range(len(array)):
if array[J] != array[-1]:
walk_cost = (array[J + 1] - array[J]) * A
if walk_cost < B:
cost += walk_cost
else:
cost += B
print(cost)
|
import sys
N, A, B = list(map(int, input().split()))
array = list(map(int, input().split()))
cost = 0
for J in range(len(array) - 1):
walk_cost = (array[J + 1] - array[J]) * A
if walk_cost < B:
cost += walk_cost
else:
cost += B
print(cost)
| false
| 36.842105
|
[
"-if not (2 <= N <= 10**5 and 1 <= A <= 10**9 and 1 <= B <= 10**9):",
"- sys.exit()",
"-for I in range(len(array)):",
"- if not (1 <= array[I] <= 10**9):",
"- sys.exit()",
"- if array[I] != array[-1]:",
"- if not (array[I] < array[I + 1]):",
"- sys.exit()",
"-for J in range(len(array)):",
"- if array[J] != array[-1]:",
"- walk_cost = (array[J + 1] - array[J]) * A",
"- if walk_cost < B:",
"- cost += walk_cost",
"- else:",
"- cost += B",
"+for J in range(len(array) - 1):",
"+ walk_cost = (array[J + 1] - array[J]) * A",
"+ if walk_cost < B:",
"+ cost += walk_cost",
"+ else:",
"+ cost += B"
] | false
| 0.036059
| 0.035775
| 1.007928
|
[
"s745335012",
"s932153856"
] |
u672475305
|
p03835
|
python
|
s871738099
|
s183552293
| 1,621
| 278
| 2,940
| 41,436
|
Accepted
|
Accepted
| 82.85
|
k,s = list(map(int,input().split()))
cnt = 0
for x in range(k+1):
for y in range(k+1):
z = s-x-y
if 0 <= z <= k:
cnt += 1
print(cnt)
|
k,s = list(map(int,input().split()))
ans = 0
for x in range(k+1):
for y in range(x, k+1):
z = s - x - y
if y<=z and z<=k:
tmp = set([x,y,z])
if len(tmp)==3:
ans += 6
elif len(tmp)==2:
ans += 3
else:
ans += 1
print(ans)
| 9
| 14
| 167
| 341
|
k, s = list(map(int, input().split()))
cnt = 0
for x in range(k + 1):
for y in range(k + 1):
z = s - x - y
if 0 <= z <= k:
cnt += 1
print(cnt)
|
k, s = list(map(int, input().split()))
ans = 0
for x in range(k + 1):
for y in range(x, k + 1):
z = s - x - y
if y <= z and z <= k:
tmp = set([x, y, z])
if len(tmp) == 3:
ans += 6
elif len(tmp) == 2:
ans += 3
else:
ans += 1
print(ans)
| false
| 35.714286
|
[
"-cnt = 0",
"+ans = 0",
"- for y in range(k + 1):",
"+ for y in range(x, k + 1):",
"- if 0 <= z <= k:",
"- cnt += 1",
"-print(cnt)",
"+ if y <= z and z <= k:",
"+ tmp = set([x, y, z])",
"+ if len(tmp) == 3:",
"+ ans += 6",
"+ elif len(tmp) == 2:",
"+ ans += 3",
"+ else:",
"+ ans += 1",
"+print(ans)"
] | false
| 0.067231
| 0.045768
| 1.468928
|
[
"s871738099",
"s183552293"
] |
u020390084
|
p03013
|
python
|
s057682473
|
s339350446
| 217
| 88
| 7,848
| 7,840
|
Accepted
|
Accepted
| 59.45
|
n, m = list(map(int,input().split()))
a = [int(eval(input())) for i in range(m)]
dp = [float("inf")] * (n+1)
dp[0] = 1
dp[1] = 1
for i in a:
dp[i] = 0
for i in range(2, n+1):
dp[i] = min(dp[i], (dp[i-1] + dp[i-2])%(10**9+7))
print((dp[n]))
|
#!/usr/bin/env python3
import sys
MOD = 1000000007 # type: int
def solve(N: int, M: int, a: "List[int]"):
#dp[i] = i段目までの移動総数
dp = [-1]*(N+1)
dp[0]=1
dp[1]=1
for i in range(M):
dp[a[i]] = 0
for i in range(2,N+1):
if dp[i] == 0:
continue
dp[i] = dp[i-1]+dp[i-2]
dp[i]%=MOD
print((dp[N]%MOD))
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
M = int(next(tokens)) # type: int
a = [int(next(tokens)) for _ in range(M)] # type: "List[int]"
solve(N, M, a)
if __name__ == '__main__':
main()
| 10
| 35
| 243
| 784
|
n, m = list(map(int, input().split()))
a = [int(eval(input())) for i in range(m)]
dp = [float("inf")] * (n + 1)
dp[0] = 1
dp[1] = 1
for i in a:
dp[i] = 0
for i in range(2, n + 1):
dp[i] = min(dp[i], (dp[i - 1] + dp[i - 2]) % (10**9 + 7))
print((dp[n]))
|
#!/usr/bin/env python3
import sys
MOD = 1000000007 # type: int
def solve(N: int, M: int, a: "List[int]"):
# dp[i] = i段目までの移動総数
dp = [-1] * (N + 1)
dp[0] = 1
dp[1] = 1
for i in range(M):
dp[a[i]] = 0
for i in range(2, N + 1):
if dp[i] == 0:
continue
dp[i] = dp[i - 1] + dp[i - 2]
dp[i] %= MOD
print((dp[N] % MOD))
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
M = int(next(tokens)) # type: int
a = [int(next(tokens)) for _ in range(M)] # type: "List[int]"
solve(N, M, a)
if __name__ == "__main__":
main()
| false
| 71.428571
|
[
"-n, m = list(map(int, input().split()))",
"-a = [int(eval(input())) for i in range(m)]",
"-dp = [float(\"inf\")] * (n + 1)",
"-dp[0] = 1",
"-dp[1] = 1",
"-for i in a:",
"- dp[i] = 0",
"-for i in range(2, n + 1):",
"- dp[i] = min(dp[i], (dp[i - 1] + dp[i - 2]) % (10**9 + 7))",
"-print((dp[n]))",
"+#!/usr/bin/env python3",
"+import sys",
"+",
"+MOD = 1000000007 # type: int",
"+",
"+",
"+def solve(N: int, M: int, a: \"List[int]\"):",
"+ # dp[i] = i段目までの移動総数",
"+ dp = [-1] * (N + 1)",
"+ dp[0] = 1",
"+ dp[1] = 1",
"+ for i in range(M):",
"+ dp[a[i]] = 0",
"+ for i in range(2, N + 1):",
"+ if dp[i] == 0:",
"+ continue",
"+ dp[i] = dp[i - 1] + dp[i - 2]",
"+ dp[i] %= MOD",
"+ print((dp[N] % MOD))",
"+ return",
"+",
"+",
"+def main():",
"+ def iterate_tokens():",
"+ for line in sys.stdin:",
"+ for word in line.split():",
"+ yield word",
"+",
"+ tokens = iterate_tokens()",
"+ N = int(next(tokens)) # type: int",
"+ M = int(next(tokens)) # type: int",
"+ a = [int(next(tokens)) for _ in range(M)] # type: \"List[int]\"",
"+ solve(N, M, a)",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false
| 0.043577
| 0.06895
| 0.632006
|
[
"s057682473",
"s339350446"
] |
u585482323
|
p03031
|
python
|
s340861998
|
s325530444
| 251
| 195
| 46,040
| 40,176
|
Accepted
|
Accepted
| 22.31
|
#!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():
a,p = LI()
print(((a*3+p)//2))
return
#B
def B():
n = I()
s = [None for i in range(n)]
for i in range(n):
l = input().split()
s[i] = l+[i]
s.sort(key = lambda x:(x[0],-int(x[1])))
for i,a,b in s:
print((b+1))
return
#C
def C():
def dfs(d,k):
if d == n:
l.append(k)
else:
dfs(d+1,k+[0])
dfs(d+1,k+[1])
n,m = LI()
l = []
dfs(0,[])
qu = LIR(m)
p = LI()
ans = 0
for k in l:
s = 0
for q in range(m):
num = qu[q][0]
lis = list([x-1 for x in qu[q][1:]])
su = 0
for i in lis:
su ^= k[i]
if su == p[q]:
s += 1
if s == m:
ans += 1
print(ans)
return
#D
def D():
n = I()
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,deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n,m = LI()
s = LIR(m)
p = LI()
ans = 0
for i in range(m):
s[i] = sum([1<<(j-1) for j in s[i][1:]])
for b in range(1<<n):
for i in range(m):
if bin(s[i]&b).count("1")&1 != p[i]:
break
else:ans += 1
print(ans)
return
#Solve
if __name__ == "__main__":
solve()
| 99
| 45
| 1,887
| 1,071
|
#!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():
a, p = LI()
print(((a * 3 + p) // 2))
return
# B
def B():
n = I()
s = [None for i in range(n)]
for i in range(n):
l = input().split()
s[i] = l + [i]
s.sort(key=lambda x: (x[0], -int(x[1])))
for i, a, b in s:
print((b + 1))
return
# C
def C():
def dfs(d, k):
if d == n:
l.append(k)
else:
dfs(d + 1, k + [0])
dfs(d + 1, k + [1])
n, m = LI()
l = []
dfs(0, [])
qu = LIR(m)
p = LI()
ans = 0
for k in l:
s = 0
for q in range(m):
num = qu[q][0]
lis = list([x - 1 for x in qu[q][1:]])
su = 0
for i in lis:
su ^= k[i]
if su == p[q]:
s += 1
if s == m:
ans += 1
print(ans)
return
# D
def D():
n = I()
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, deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def I():
return int(sys.stdin.readline())
def LS():
return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n, m = LI()
s = LIR(m)
p = LI()
ans = 0
for i in range(m):
s[i] = sum([1 << (j - 1) for j in s[i][1:]])
for b in range(1 << n):
for i in range(m):
if bin(s[i] & b).count("1") & 1 != p[i]:
break
else:
ans += 1
print(ans)
return
# Solve
if __name__ == "__main__":
solve()
| false
| 54.545455
|
[
"-from collections import defaultdict",
"-from collections import deque",
"+from collections import defaultdict, deque",
"- return list(map(int, sys.stdin.readline().split()))",
"+ return [int(x) for x in sys.stdin.readline().split()]",
"- return list(map(list, sys.stdin.readline().split()))",
"+ return [list(x) for x in sys.stdin.readline().split()]",
"- return list(sys.stdin.readline())[:-1]",
"+ res = list(sys.stdin.readline())",
"+ if res[-1] == \"\\n\":",
"+ return res[:-1]",
"+ return res",
"- l = [None for i in range(n)]",
"- for i in range(n):",
"- l[i] = I()",
"- return l",
"+ return [I() for i in range(n)]",
"- l = [None for i in range(n)]",
"- for i in range(n):",
"- l[i] = LI()",
"- return l",
"+ return [LI() for i in range(n)]",
"- l = [None for i in range(n)]",
"- for i in range(n):",
"- l[i] = S()",
"- return l",
"+ return [S() for i in range(n)]",
"- l = [None for i in range(n)]",
"- for i in range(n):",
"- l[i] = LS()",
"- return l",
"+ return [LS() for i in range(n)]",
"-# A",
"-def A():",
"- a, p = LI()",
"- print(((a * 3 + p) // 2))",
"- return",
"-# B",
"-def B():",
"- n = I()",
"- s = [None for i in range(n)]",
"- for i in range(n):",
"- l = input().split()",
"- s[i] = l + [i]",
"- s.sort(key=lambda x: (x[0], -int(x[1])))",
"- for i, a, b in s:",
"- print((b + 1))",
"- return",
"-",
"-",
"-# C",
"-def C():",
"- def dfs(d, k):",
"- if d == n:",
"- l.append(k)",
"- else:",
"- dfs(d + 1, k + [0])",
"- dfs(d + 1, k + [1])",
"-",
"+def solve():",
"- l = []",
"- dfs(0, [])",
"- qu = LIR(m)",
"+ s = LIR(m)",
"- for k in l:",
"- s = 0",
"- for q in range(m):",
"- num = qu[q][0]",
"- lis = list([x - 1 for x in qu[q][1:]])",
"- su = 0",
"- for i in lis:",
"- su ^= k[i]",
"- if su == p[q]:",
"- s += 1",
"- if s == m:",
"+ for i in range(m):",
"+ s[i] = sum([1 << (j - 1) for j in s[i][1:]])",
"+ for b in range(1 << n):",
"+ for i in range(m):",
"+ if bin(s[i] & b).count(\"1\") & 1 != p[i]:",
"+ break",
"+ else:",
"-# D",
"-def D():",
"- n = I()",
"- return",
"-",
"-",
"-# E",
"-def E():",
"- n = I()",
"- return",
"-",
"-",
"-# F",
"-def F():",
"- n = I()",
"- return",
"-",
"-",
"- C()",
"+ solve()"
] | false
| 0.05801
| 0.100603
| 0.576624
|
[
"s340861998",
"s325530444"
] |
u624689667
|
p03111
|
python
|
s927984891
|
s335460373
| 297
| 245
| 49,392
| 45,276
|
Accepted
|
Accepted
| 17.51
|
import itertools
n_bamboo, b1, b2, b3 = [int(i) for i in input().split()]
bamboos = [int(eval(input())) for _ in range(n_bamboo)]
ans = float("inf")
# すべての竹について、b1, b2, b3のどの竹に使うかを列挙
# 0のときはどの竹にも使わない
for bit in itertools.product((0, 1, 2, 3), repeat=n_bamboo):
l1, l2, l3 = 0, 0, 0
c1, c2, c3 = 0, 0, 0
# 選択した竹を足す（2つ目以降はMP10消費）
for b, bamboo in zip(bit, bamboos):
if b == 1:
if l1 > 0:
c1 += 10
l1 += bamboo
elif b == 2:
if l2 > 0:
c2 += 10
l2 += bamboo
elif b == 3:
if l3 > 0:
c3 += 10
l3 += bamboo
# 1つも構成する竹がない竹がある場合はスキップ
if l1 * l2 * l3 == 0:
continue
# 延長、短縮のコスト
c1 += abs(b1 - l1)
c2 += abs(b2 - l2)
c3 += abs(b3 - l3)
# 合計コストが今までより低ければ更新
ans = min(ans, c1 + c2 + c3)
print(ans)
|
def dfs(cursor, a, b, c):
if cursor == N:
return abs(A - a) + abs(B - b) + abs(C - c) - 30 if min(a, b, c) > 0 else float("inf")
ret0 = dfs(cursor + 1, a, b, c)
ret1 = dfs(cursor + 1, a + l[cursor], b, c) + 10
ret2 = dfs(cursor + 1, a, b + l[cursor], c) + 10
ret3 = dfs(cursor + 1, a, b, c + l[cursor]) + 10
return min(ret0, ret1, ret2, ret3)
N, A, B, C = [int(i) for i in input().split()]
l = [int(eval(input())) for _ in range(N)]
print((dfs(0, 0, 0, 0)))
| 36
| 13
| 917
| 496
|
import itertools
n_bamboo, b1, b2, b3 = [int(i) for i in input().split()]
bamboos = [int(eval(input())) for _ in range(n_bamboo)]
ans = float("inf")
# すべての竹について、b1, b2, b3のどの竹に使うかを列挙
# 0のときはどの竹にも使わない
for bit in itertools.product((0, 1, 2, 3), repeat=n_bamboo):
l1, l2, l3 = 0, 0, 0
c1, c2, c3 = 0, 0, 0
# 選択した竹を足す（2つ目以降はMP10消費）
for b, bamboo in zip(bit, bamboos):
if b == 1:
if l1 > 0:
c1 += 10
l1 += bamboo
elif b == 2:
if l2 > 0:
c2 += 10
l2 += bamboo
elif b == 3:
if l3 > 0:
c3 += 10
l3 += bamboo
# 1つも構成する竹がない竹がある場合はスキップ
if l1 * l2 * l3 == 0:
continue
# 延長、短縮のコスト
c1 += abs(b1 - l1)
c2 += abs(b2 - l2)
c3 += abs(b3 - l3)
# 合計コストが今までより低ければ更新
ans = min(ans, c1 + c2 + c3)
print(ans)
|
def dfs(cursor, a, b, c):
if cursor == N:
return (
abs(A - a) + abs(B - b) + abs(C - c) - 30
if min(a, b, c) > 0
else float("inf")
)
ret0 = dfs(cursor + 1, a, b, c)
ret1 = dfs(cursor + 1, a + l[cursor], b, c) + 10
ret2 = dfs(cursor + 1, a, b + l[cursor], c) + 10
ret3 = dfs(cursor + 1, a, b, c + l[cursor]) + 10
return min(ret0, ret1, ret2, ret3)
N, A, B, C = [int(i) for i in input().split()]
l = [int(eval(input())) for _ in range(N)]
print((dfs(0, 0, 0, 0)))
| false
| 63.888889
|
[
"-import itertools",
"+def dfs(cursor, a, b, c):",
"+ if cursor == N:",
"+ return (",
"+ abs(A - a) + abs(B - b) + abs(C - c) - 30",
"+ if min(a, b, c) > 0",
"+ else float(\"inf\")",
"+ )",
"+ ret0 = dfs(cursor + 1, a, b, c)",
"+ ret1 = dfs(cursor + 1, a + l[cursor], b, c) + 10",
"+ ret2 = dfs(cursor + 1, a, b + l[cursor], c) + 10",
"+ ret3 = dfs(cursor + 1, a, b, c + l[cursor]) + 10",
"+ return min(ret0, ret1, ret2, ret3)",
"-n_bamboo, b1, b2, b3 = [int(i) for i in input().split()]",
"-bamboos = [int(eval(input())) for _ in range(n_bamboo)]",
"-ans = float(\"inf\")",
"-# すべての竹について、b1, b2, b3のどの竹に使うかを列挙",
"-# 0のときはどの竹にも使わない",
"-for bit in itertools.product((0, 1, 2, 3), repeat=n_bamboo):",
"- l1, l2, l3 = 0, 0, 0",
"- c1, c2, c3 = 0, 0, 0",
"- # 選択した竹を足す（2つ目以降はMP10消費）",
"- for b, bamboo in zip(bit, bamboos):",
"- if b == 1:",
"- if l1 > 0:",
"- c1 += 10",
"- l1 += bamboo",
"- elif b == 2:",
"- if l2 > 0:",
"- c2 += 10",
"- l2 += bamboo",
"- elif b == 3:",
"- if l3 > 0:",
"- c3 += 10",
"- l3 += bamboo",
"- # 1つも構成する竹がない竹がある場合はスキップ",
"- if l1 * l2 * l3 == 0:",
"- continue",
"- # 延長、短縮のコスト",
"- c1 += abs(b1 - l1)",
"- c2 += abs(b2 - l2)",
"- c3 += abs(b3 - l3)",
"- # 合計コストが今までより低ければ更新",
"- ans = min(ans, c1 + c2 + c3)",
"-print(ans)",
"+",
"+N, A, B, C = [int(i) for i in input().split()]",
"+l = [int(eval(input())) for _ in range(N)]",
"+print((dfs(0, 0, 0, 0)))"
] | false
| 0.315025
| 0.095773
| 3.28929
|
[
"s927984891",
"s335460373"
] |
u188827677
|
p03339
|
python
|
s500297093
|
s248071109
| 265
| 236
| 23,504
| 23,428
|
Accepted
|
Accepted
| 10.94
|
n = int(eval(input()))
s = eval(input())
w = [0]*n
e = [0]*n
for i in range(n):
if s[i] == "W": w[i] += 1
else: e[i] += 1
if i != n-1:
w[i+1] = w[i]
e[i+1] = e[i]
ans = e[-1]-e[0]
for i in range(1,n):
ans = min(ans, w[i-1] + e[-1]-e[i])
print(ans)
|
n = int(eval(input()))
s = eval(input())
w = [0]*n
e = [0]*n
if s[0] == "W": w[0] = 1
else: e[0] = 1
for i in range(1,n):
if s[i] == "W":
w[i] = w[i-1]+1
e[i] = e[i-1]
else:
w[i] = w[i-1]
e[i] = e[i-1]+1
ans = float("inf")
for i in range(n):
t = 0
if i != 0: t += w[i-1]
if i != n-1: t += e[-1] - e[i]
if t < ans: ans = t
print(ans)
| 17
| 22
| 270
| 373
|
n = int(eval(input()))
s = eval(input())
w = [0] * n
e = [0] * n
for i in range(n):
if s[i] == "W":
w[i] += 1
else:
e[i] += 1
if i != n - 1:
w[i + 1] = w[i]
e[i + 1] = e[i]
ans = e[-1] - e[0]
for i in range(1, n):
ans = min(ans, w[i - 1] + e[-1] - e[i])
print(ans)
|
n = int(eval(input()))
s = eval(input())
w = [0] * n
e = [0] * n
if s[0] == "W":
w[0] = 1
else:
e[0] = 1
for i in range(1, n):
if s[i] == "W":
w[i] = w[i - 1] + 1
e[i] = e[i - 1]
else:
w[i] = w[i - 1]
e[i] = e[i - 1] + 1
ans = float("inf")
for i in range(n):
t = 0
if i != 0:
t += w[i - 1]
if i != n - 1:
t += e[-1] - e[i]
if t < ans:
ans = t
print(ans)
| false
| 22.727273
|
[
"+if s[0] == \"W\":",
"+ w[0] = 1",
"+else:",
"+ e[0] = 1",
"+for i in range(1, n):",
"+ if s[i] == \"W\":",
"+ w[i] = w[i - 1] + 1",
"+ e[i] = e[i - 1]",
"+ else:",
"+ w[i] = w[i - 1]",
"+ e[i] = e[i - 1] + 1",
"+ans = float(\"inf\")",
"- if s[i] == \"W\":",
"- w[i] += 1",
"- else:",
"- e[i] += 1",
"+ t = 0",
"+ if i != 0:",
"+ t += w[i - 1]",
"- w[i + 1] = w[i]",
"- e[i + 1] = e[i]",
"-ans = e[-1] - e[0]",
"-for i in range(1, n):",
"- ans = min(ans, w[i - 1] + e[-1] - e[i])",
"+ t += e[-1] - e[i]",
"+ if t < ans:",
"+ ans = t"
] | false
| 0.041799
| 0.037773
| 1.106592
|
[
"s500297093",
"s248071109"
] |
u467041847
|
p03416
|
python
|
s490395080
|
s379388378
| 62
| 46
| 2,940
| 3,060
|
Accepted
|
Accepted
| 25.81
|
A,B = list(map(int,input().split()))
def kaibun(m, n):
key = 0
for i in range(m,n+1):
if str(i) == str(i)[::-1]:
key += 1
return key
print((kaibun(A,B)))
|
A,B = list(map(int,input().split()))
def kaibun(m, n):
key = 0
for i in range(m,n+1):
s = i//10000
t = i%10
u = i//1000 % 10
v = i//10 % 10
if (s==t)&(u==v):
key += 1
return key
print((kaibun(A,B)))
| 11
| 14
| 166
| 273
|
A, B = list(map(int, input().split()))
def kaibun(m, n):
key = 0
for i in range(m, n + 1):
if str(i) == str(i)[::-1]:
key += 1
return key
print((kaibun(A, B)))
|
A, B = list(map(int, input().split()))
def kaibun(m, n):
key = 0
for i in range(m, n + 1):
s = i // 10000
t = i % 10
u = i // 1000 % 10
v = i // 10 % 10
if (s == t) & (u == v):
key += 1
return key
print((kaibun(A, B)))
| false
| 21.428571
|
[
"- if str(i) == str(i)[::-1]:",
"+ s = i // 10000",
"+ t = i % 10",
"+ u = i // 1000 % 10",
"+ v = i // 10 % 10",
"+ if (s == t) & (u == v):"
] | false
| 0.211605
| 0.035976
| 5.881851
|
[
"s490395080",
"s379388378"
] |
u163320134
|
p02930
|
python
|
s707476799
|
s076812140
| 192
| 64
| 11,384
| 11,296
|
Accepted
|
Accepted
| 66.67
|
n=int(eval(input()))
ans=[[0]*n for _ in range(n)]
for i in range(n):
for j in range(n):
tmp=i^j
if tmp==0:
ans[i][j]=1
else:
tmp=format(tmp,'b')[::-1]
ans[i][j]=tmp.index('1')+1
for i in range(n-1):
print((*ans[i][i+1:]))
|
def dfs(color,l,r):
if l==r:
return
for i in range(l,(l+r)//2+1):
for j in range((l+r)//2+1,r+1):
ans[i][j]=color
dfs(color+1,l,(l+r)//2)
dfs(color+1,(l+r)//2+1,r)
n=int(eval(input()))
ans=[[0]*(n+1) for _ in range(n+1)]
dfs(1,1,n)
for i in range(1,n):
print((*ans[i][i+1:n+1]))
| 12
| 14
| 259
| 308
|
n = int(eval(input()))
ans = [[0] * n for _ in range(n)]
for i in range(n):
for j in range(n):
tmp = i ^ j
if tmp == 0:
ans[i][j] = 1
else:
tmp = format(tmp, "b")[::-1]
ans[i][j] = tmp.index("1") + 1
for i in range(n - 1):
print((*ans[i][i + 1 :]))
|
def dfs(color, l, r):
if l == r:
return
for i in range(l, (l + r) // 2 + 1):
for j in range((l + r) // 2 + 1, r + 1):
ans[i][j] = color
dfs(color + 1, l, (l + r) // 2)
dfs(color + 1, (l + r) // 2 + 1, r)
n = int(eval(input()))
ans = [[0] * (n + 1) for _ in range(n + 1)]
dfs(1, 1, n)
for i in range(1, n):
print((*ans[i][i + 1 : n + 1]))
| false
| 14.285714
|
[
"+def dfs(color, l, r):",
"+ if l == r:",
"+ return",
"+ for i in range(l, (l + r) // 2 + 1):",
"+ for j in range((l + r) // 2 + 1, r + 1):",
"+ ans[i][j] = color",
"+ dfs(color + 1, l, (l + r) // 2)",
"+ dfs(color + 1, (l + r) // 2 + 1, r)",
"+",
"+",
"-ans = [[0] * n for _ in range(n)]",
"-for i in range(n):",
"- for j in range(n):",
"- tmp = i ^ j",
"- if tmp == 0:",
"- ans[i][j] = 1",
"- else:",
"- tmp = format(tmp, \"b\")[::-1]",
"- ans[i][j] = tmp.index(\"1\") + 1",
"-for i in range(n - 1):",
"- print((*ans[i][i + 1 :]))",
"+ans = [[0] * (n + 1) for _ in range(n + 1)]",
"+dfs(1, 1, n)",
"+for i in range(1, n):",
"+ print((*ans[i][i + 1 : n + 1]))"
] | false
| 0.04558
| 0.043269
| 1.053414
|
[
"s707476799",
"s076812140"
] |
u837673618
|
p02744
|
python
|
s362792274
|
s646725844
| 187
| 150
| 4,412
| 5,028
|
Accepted
|
Accepted
| 19.79
|
def gen_pattern(N, pre=""):
for c in range(0x61, ord(max(pre or "\x60"))+2):
pat = pre+chr(c)
if len(pat) == N:
yield pat
else:
yield from gen_pattern(N, pat)
for pattern in gen_pattern(int(eval(input()))):
print(pattern)
|
from string import ascii_lowercase as alph
def gen_pattern(N, pre="", m=0):
if len(pre)+1 == N:
for c in alph[:m+1]:
yield pre+c
else:
for c in alph[:m]:
yield from gen_pattern(N, pre+c, m)
yield from gen_pattern(N, pre+alph[m], m+1)
for pattern in gen_pattern(int(eval(input()))):
print(pattern)
| 10
| 13
| 254
| 335
|
def gen_pattern(N, pre=""):
for c in range(0x61, ord(max(pre or "\x60")) + 2):
pat = pre + chr(c)
if len(pat) == N:
yield pat
else:
yield from gen_pattern(N, pat)
for pattern in gen_pattern(int(eval(input()))):
print(pattern)
|
from string import ascii_lowercase as alph
def gen_pattern(N, pre="", m=0):
if len(pre) + 1 == N:
for c in alph[: m + 1]:
yield pre + c
else:
for c in alph[:m]:
yield from gen_pattern(N, pre + c, m)
yield from gen_pattern(N, pre + alph[m], m + 1)
for pattern in gen_pattern(int(eval(input()))):
print(pattern)
| false
| 23.076923
|
[
"-def gen_pattern(N, pre=\"\"):",
"- for c in range(0x61, ord(max(pre or \"\\x60\")) + 2):",
"- pat = pre + chr(c)",
"- if len(pat) == N:",
"- yield pat",
"- else:",
"- yield from gen_pattern(N, pat)",
"+from string import ascii_lowercase as alph",
"+",
"+",
"+def gen_pattern(N, pre=\"\", m=0):",
"+ if len(pre) + 1 == N:",
"+ for c in alph[: m + 1]:",
"+ yield pre + c",
"+ else:",
"+ for c in alph[:m]:",
"+ yield from gen_pattern(N, pre + c, m)",
"+ yield from gen_pattern(N, pre + alph[m], m + 1)"
] | false
| 0.048131
| 0.081946
| 0.587349
|
[
"s362792274",
"s646725844"
] |
u767664985
|
p03549
|
python
|
s244617081
|
s304804101
| 170
| 18
| 38,384
| 2,940
|
Accepted
|
Accepted
| 89.41
|
N, M = list(map(int, input().split()))
print(((1900 * M + 100 * (N - M)) * 2 ** M))
|
N, M = list(map(int, input().split()))
time = 1900*M + 100*(N-M)
print((2**M * time))
| 2
| 4
| 77
| 82
|
N, M = list(map(int, input().split()))
print(((1900 * M + 100 * (N - M)) * 2**M))
|
N, M = list(map(int, input().split()))
time = 1900 * M + 100 * (N - M)
print((2**M * time))
| false
| 50
|
[
"-print(((1900 * M + 100 * (N - M)) * 2**M))",
"+time = 1900 * M + 100 * (N - M)",
"+print((2**M * time))"
] | false
| 0.137896
| 0.065393
| 2.10874
|
[
"s244617081",
"s304804101"
] |
u386782537
|
p03087
|
python
|
s404463408
|
s807024197
| 1,001
| 461
| 51,416
| 30,688
|
Accepted
|
Accepted
| 53.95
|
N, Q = list(map(int, input().split()))
S =eval(input())
AC_list = [0]*N
count = 0
for i in range(1,N):
if (S[i-1] + S[i]) == "AC":
count +=1
AC_list[i] = count
for i in range(Q):
l, r = list(map(int, input().split()))
print((AC_list[r-1] - AC_list[l-1]))
|
N, Q = list(map(int, input().split()))
S =eval(input())
length = [list(map(int, input().split())) for _ in range(Q)]
AC_list = [0]*N
count = 0
for i in range(1,N):
if (S[i-1] + S[i]) == "AC":
count +=1
AC_list[i] = count
for l, r in length:
print((AC_list[r-1] - AC_list[l-1]))
| 15
| 12
| 268
| 286
|
N, Q = list(map(int, input().split()))
S = eval(input())
AC_list = [0] * N
count = 0
for i in range(1, N):
if (S[i - 1] + S[i]) == "AC":
count += 1
AC_list[i] = count
for i in range(Q):
l, r = list(map(int, input().split()))
print((AC_list[r - 1] - AC_list[l - 1]))
|
N, Q = list(map(int, input().split()))
S = eval(input())
length = [list(map(int, input().split())) for _ in range(Q)]
AC_list = [0] * N
count = 0
for i in range(1, N):
if (S[i - 1] + S[i]) == "AC":
count += 1
AC_list[i] = count
for l, r in length:
print((AC_list[r - 1] - AC_list[l - 1]))
| false
| 20
|
[
"+length = [list(map(int, input().split())) for _ in range(Q)]",
"-for i in range(Q):",
"- l, r = list(map(int, input().split()))",
"+for l, r in length:"
] | false
| 0.036197
| 0.08486
| 0.426555
|
[
"s404463408",
"s807024197"
] |
u197615397
|
p02345
|
python
|
s787694715
|
s251155591
| 1,130
| 900
| 16,352
| 16,352
|
Accepted
|
Accepted
| 20.35
|
import math
import sys
class SegmentTree(object):
__slots__ = ["elem_size", "tree_size", "tree", "default", "op"]
def __init__(self, a: list, default: int, op):
real_size = len(a)
self.elem_size = 1 << math.ceil(math.log2(real_size))
self.tree_size = 2 * self.elem_size
self.tree = tree = [default] * self.elem_size + a + [default] * (self.elem_size - real_size)
self.default = default
self.op = op
for i in range(self.elem_size - 1, 0, -1):
tree[i] = op(tree[i<<1], tree[(i<<1)+1])
def get_value(self, x: int, y: int):
l, r = x + self.elem_size, y + self.elem_size
tree, result, op = self.tree, self.default, self.op
while l < r:
if l & 1:
result = op(tree[l], result)
l += 1
if r & 1:
r -= 1
result = op(tree[r], result)
l, r = l >> 1, r >> 1
return result
def set_value(self, i: int, value: int):
k = self.elem_size + i
self.tree[k] = value
self.update(k)
def update(self, i: int):
op, tree = self.op, self.tree
while i > 1:
i >>= 1
tree[i] = op(tree[i<<1], tree[(i<<1) + 1])
if __name__ == "__main__":
n, q = map(int, input().split())
tree = SegmentTree([2**31-1]*n, 2**31-1, min)
ans = []
append = ans.append
for com, x, y in (map(int, l.split()) for l in sys.stdin.readlines()):
if com == 0:
tree.set_value(x, y)
else:
append(tree.get_value(x, y+1))
print(*ans, sep="\n")
|
import math
import sys
class SegmentTree(object):
__slots__ = ["elem_size", "tree", "default"]
def __init__(self, a: list, default: int):
real_size = len(a)
self.elem_size = elem_size = 1 << math.ceil(math.log2(real_size))
self.tree = tree = [default] * (elem_size * 2)
tree[elem_size:elem_size+real_size] = a
self.default = default
for i in range(elem_size - 1, 0, -1):
l, r = tree[i<<1], tree[(i<<1)+1]
tree[i] = l if l < r else r
def get_value(self, x: int, y: int) -> int:
l, r = x + self.elem_size, y + self.elem_size
tree, result = self.tree, self.default
while l < r:
if l & 1:
if tree[l] < result:
result = tree[l]
l += 1
if r & 1:
r -= 1
if tree[r] < result:
result = tree[r]
l, r = l >> 1, r >> 1
return result
def set_value(self, i: int, value: int) -> None:
k = self.elem_size + i
self.tree[k] = value
self.update(k)
def update(self, i: int) -> None:
tree = self.tree
while i > 1:
i >>= 1
l, r = tree[i<<1], tree[(i<<1)+1]
tree[i] = l if l < r else r
n, q = map(int, input().split())
tree = SegmentTree([2**31-1]*n, 2**31-1)
ans = []
append = ans.append
for com, x, y in (map(int, l.split()) for l in sys.stdin.readlines()):
if com == 0:
tree.set_value(x, y)
else:
append(tree.get_value(x, y+1))
print(*ans, sep="\n")
| 53
| 55
| 1,686
| 1,657
|
import math
import sys
class SegmentTree(object):
__slots__ = ["elem_size", "tree_size", "tree", "default", "op"]
def __init__(self, a: list, default: int, op):
real_size = len(a)
self.elem_size = 1 << math.ceil(math.log2(real_size))
self.tree_size = 2 * self.elem_size
self.tree = tree = (
[default] * self.elem_size + a + [default] * (self.elem_size - real_size)
)
self.default = default
self.op = op
for i in range(self.elem_size - 1, 0, -1):
tree[i] = op(tree[i << 1], tree[(i << 1) + 1])
def get_value(self, x: int, y: int):
l, r = x + self.elem_size, y + self.elem_size
tree, result, op = self.tree, self.default, self.op
while l < r:
if l & 1:
result = op(tree[l], result)
l += 1
if r & 1:
r -= 1
result = op(tree[r], result)
l, r = l >> 1, r >> 1
return result
def set_value(self, i: int, value: int):
k = self.elem_size + i
self.tree[k] = value
self.update(k)
def update(self, i: int):
op, tree = self.op, self.tree
while i > 1:
i >>= 1
tree[i] = op(tree[i << 1], tree[(i << 1) + 1])
if __name__ == "__main__":
n, q = map(int, input().split())
tree = SegmentTree([2**31 - 1] * n, 2**31 - 1, min)
ans = []
append = ans.append
for com, x, y in (map(int, l.split()) for l in sys.stdin.readlines()):
if com == 0:
tree.set_value(x, y)
else:
append(tree.get_value(x, y + 1))
print(*ans, sep="\n")
|
import math
import sys
class SegmentTree(object):
__slots__ = ["elem_size", "tree", "default"]
def __init__(self, a: list, default: int):
real_size = len(a)
self.elem_size = elem_size = 1 << math.ceil(math.log2(real_size))
self.tree = tree = [default] * (elem_size * 2)
tree[elem_size : elem_size + real_size] = a
self.default = default
for i in range(elem_size - 1, 0, -1):
l, r = tree[i << 1], tree[(i << 1) + 1]
tree[i] = l if l < r else r
def get_value(self, x: int, y: int) -> int:
l, r = x + self.elem_size, y + self.elem_size
tree, result = self.tree, self.default
while l < r:
if l & 1:
if tree[l] < result:
result = tree[l]
l += 1
if r & 1:
r -= 1
if tree[r] < result:
result = tree[r]
l, r = l >> 1, r >> 1
return result
def set_value(self, i: int, value: int) -> None:
k = self.elem_size + i
self.tree[k] = value
self.update(k)
def update(self, i: int) -> None:
tree = self.tree
while i > 1:
i >>= 1
l, r = tree[i << 1], tree[(i << 1) + 1]
tree[i] = l if l < r else r
n, q = map(int, input().split())
tree = SegmentTree([2**31 - 1] * n, 2**31 - 1)
ans = []
append = ans.append
for com, x, y in (map(int, l.split()) for l in sys.stdin.readlines()):
if com == 0:
tree.set_value(x, y)
else:
append(tree.get_value(x, y + 1))
print(*ans, sep="\n")
| false
| 3.636364
|
[
"- __slots__ = [\"elem_size\", \"tree_size\", \"tree\", \"default\", \"op\"]",
"+ __slots__ = [\"elem_size\", \"tree\", \"default\"]",
"- def __init__(self, a: list, default: int, op):",
"+ def __init__(self, a: list, default: int):",
"- self.elem_size = 1 << math.ceil(math.log2(real_size))",
"- self.tree_size = 2 * self.elem_size",
"- self.tree = tree = (",
"- [default] * self.elem_size + a + [default] * (self.elem_size - real_size)",
"- )",
"+ self.elem_size = elem_size = 1 << math.ceil(math.log2(real_size))",
"+ self.tree = tree = [default] * (elem_size * 2)",
"+ tree[elem_size : elem_size + real_size] = a",
"- self.op = op",
"- for i in range(self.elem_size - 1, 0, -1):",
"- tree[i] = op(tree[i << 1], tree[(i << 1) + 1])",
"+ for i in range(elem_size - 1, 0, -1):",
"+ l, r = tree[i << 1], tree[(i << 1) + 1]",
"+ tree[i] = l if l < r else r",
"- def get_value(self, x: int, y: int):",
"+ def get_value(self, x: int, y: int) -> int:",
"- tree, result, op = self.tree, self.default, self.op",
"+ tree, result = self.tree, self.default",
"- result = op(tree[l], result)",
"+ if tree[l] < result:",
"+ result = tree[l]",
"- result = op(tree[r], result)",
"+ if tree[r] < result:",
"+ result = tree[r]",
"- def set_value(self, i: int, value: int):",
"+ def set_value(self, i: int, value: int) -> None:",
"- def update(self, i: int):",
"- op, tree = self.op, self.tree",
"+ def update(self, i: int) -> None:",
"+ tree = self.tree",
"- tree[i] = op(tree[i << 1], tree[(i << 1) + 1])",
"+ l, r = tree[i << 1], tree[(i << 1) + 1]",
"+ tree[i] = l if l < r else r",
"-if __name__ == \"__main__\":",
"- n, q = map(int, input().split())",
"- tree = SegmentTree([2**31 - 1] * n, 2**31 - 1, min)",
"- ans = []",
"- append = ans.append",
"- for com, x, y in (map(int, l.split()) for l in sys.stdin.readlines()):",
"- if com == 0:",
"- tree.set_value(x, y)",
"- else:",
"- append(tree.get_value(x, y + 1))",
"- print(*ans, sep=\"\\n\")",
"+n, q = map(int, input().split())",
"+tree = SegmentTree([2**31 - 1] * n, 2**31 - 1)",
"+ans = []",
"+append = ans.append",
"+for com, x, y in (map(int, l.split()) for l in sys.stdin.readlines()):",
"+ if com == 0:",
"+ tree.set_value(x, y)",
"+ else:",
"+ append(tree.get_value(x, y + 1))",
"+print(*ans, sep=\"\\n\")"
] | false
| 0.152536
| 0.098052
| 1.555661
|
[
"s787694715",
"s251155591"
] |
u077291787
|
p02971
|
python
|
s665715395
|
s467935443
| 267
| 245
| 23,728
| 23,728
|
Accepted
|
Accepted
| 8.24
|
# ABC134
import sys
input = sys.stdin.readline
def main():
n = int(input())
A = list(map(int, [input() for _ in range(n)]))
SA = sorted(A)
ma, ma2 = SA[-1], SA[-2]
ans = [ma if i != ma else ma2 for i in A]
print(*ans, sep="\n")
if __name__ == "__main__":
main()
|
# ABC134
import sys
input = sys.stdin.readline
def main():
n = int(input())
A = list(map(int, [input() for _ in range(n)]))
SA = sorted(A)
ma, ma2 = SA[-1], SA[-2]
ans = (ma if i != ma else ma2 for i in A)
print(*ans, sep="\n")
if __name__ == "__main__":
main()
| 15
| 15
| 306
| 306
|
# ABC134
import sys
input = sys.stdin.readline
def main():
n = int(input())
A = list(map(int, [input() for _ in range(n)]))
SA = sorted(A)
ma, ma2 = SA[-1], SA[-2]
ans = [ma if i != ma else ma2 for i in A]
print(*ans, sep="\n")
if __name__ == "__main__":
main()
|
# ABC134
import sys
input = sys.stdin.readline
def main():
n = int(input())
A = list(map(int, [input() for _ in range(n)]))
SA = sorted(A)
ma, ma2 = SA[-1], SA[-2]
ans = (ma if i != ma else ma2 for i in A)
print(*ans, sep="\n")
if __name__ == "__main__":
main()
| false
| 0
|
[
"- ans = [ma if i != ma else ma2 for i in A]",
"+ ans = (ma if i != ma else ma2 for i in A)"
] | false
| 0.038644
| 0.042612
| 0.906878
|
[
"s665715395",
"s467935443"
] |
u888092736
|
p03624
|
python
|
s480021361
|
s557175043
| 25
| 19
| 3,832
| 3,188
|
Accepted
|
Accepted
| 24
|
from string import ascii_lowercase
S = eval(input())
ans = None
for c in ascii_lowercase:
if c not in S:
ans = c
break
print(ans)
|
S = eval(input())
ans = None
for c in 'abcdefghijklmnopqrstuvwxyz':
if c not in S:
ans = c
break
print(ans)
| 10
| 7
| 154
| 127
|
from string import ascii_lowercase
S = eval(input())
ans = None
for c in ascii_lowercase:
if c not in S:
ans = c
break
print(ans)
|
S = eval(input())
ans = None
for c in "abcdefghijklmnopqrstuvwxyz":
if c not in S:
ans = c
break
print(ans)
| false
| 30
|
[
"-from string import ascii_lowercase",
"-",
"-for c in ascii_lowercase:",
"+for c in \"abcdefghijklmnopqrstuvwxyz\":"
] | false
| 0.063005
| 0.048156
| 1.308359
|
[
"s480021361",
"s557175043"
] |
u249218427
|
p02678
|
python
|
s754033551
|
s067945516
| 535
| 483
| 48,124
| 46,016
|
Accepted
|
Accepted
| 9.72
|
# -*- coding: utf-8 -*-
import sys
N, M, *AB = list(map(int, sys.stdin.buffer.read().split()))
dict_path = {i+1: [] for i in range(N)}
for i in range(M):
A,B = AB[2*i:2*i+2]
dict_path[A].append(B)
dict_path[B].append(A)
list_bfs = [1]
list_flg = [0 for _ in range(N+1)]
list_flg[1] = 1
while len(list_bfs)>0:
list_tmp = []
for i in list_bfs:
for j in dict_path[i]:
if list_flg[j]==0:
list_tmp.append(j)
list_flg[j] = i
list_bfs = list_tmp
print('Yes')
for i in list_flg[2:]:
print(i)
|
# -*- coding: utf-8 -*-
import sys
N, M, *AB = list(map(int, sys.stdin.buffer.read().split()))
list_path = [[] for _ in range(N+1)]
for i in range(M):
A,B = AB[2*i:2*i+2]
list_path[A].append(B)
list_path[B].append(A)
list_bfs = [1]
list_flg = [0 for _ in range(N+1)]
list_flg[1] = 1
while len(list_bfs)>0:
list_tmp = []
for i in list_bfs:
for j in list_path[i]:
if list_flg[j]==0:
list_tmp.append(j)
list_flg[j] = i
list_bfs = list_tmp
print('Yes')
for i in list_flg[2:]:
print(i)
| 28
| 28
| 550
| 548
|
# -*- coding: utf-8 -*-
import sys
N, M, *AB = list(map(int, sys.stdin.buffer.read().split()))
dict_path = {i + 1: [] for i in range(N)}
for i in range(M):
A, B = AB[2 * i : 2 * i + 2]
dict_path[A].append(B)
dict_path[B].append(A)
list_bfs = [1]
list_flg = [0 for _ in range(N + 1)]
list_flg[1] = 1
while len(list_bfs) > 0:
list_tmp = []
for i in list_bfs:
for j in dict_path[i]:
if list_flg[j] == 0:
list_tmp.append(j)
list_flg[j] = i
list_bfs = list_tmp
print("Yes")
for i in list_flg[2:]:
print(i)
|
# -*- coding: utf-8 -*-
import sys
N, M, *AB = list(map(int, sys.stdin.buffer.read().split()))
list_path = [[] for _ in range(N + 1)]
for i in range(M):
A, B = AB[2 * i : 2 * i + 2]
list_path[A].append(B)
list_path[B].append(A)
list_bfs = [1]
list_flg = [0 for _ in range(N + 1)]
list_flg[1] = 1
while len(list_bfs) > 0:
list_tmp = []
for i in list_bfs:
for j in list_path[i]:
if list_flg[j] == 0:
list_tmp.append(j)
list_flg[j] = i
list_bfs = list_tmp
print("Yes")
for i in list_flg[2:]:
print(i)
| false
| 0
|
[
"-dict_path = {i + 1: [] for i in range(N)}",
"+list_path = [[] for _ in range(N + 1)]",
"- dict_path[A].append(B)",
"- dict_path[B].append(A)",
"+ list_path[A].append(B)",
"+ list_path[B].append(A)",
"- for j in dict_path[i]:",
"+ for j in list_path[i]:"
] | false
| 0.062127
| 0.045229
| 1.373606
|
[
"s754033551",
"s067945516"
] |
u355371431
|
p02753
|
python
|
s474803876
|
s986186045
| 186
| 17
| 39,732
| 2,940
|
Accepted
|
Accepted
| 90.86
|
S = eval(input())
A = 0
B = 0
for i in S:
if i == "A":
A+=1
elif i == "B":
B += 1
if A == 3 or B == 3:
print("No")
else:
print("Yes")
|
S = eval(input())
if S == "AAA" or S == "BBB":
print("No")
else:
print("Yes")
| 13
| 5
| 172
| 83
|
S = eval(input())
A = 0
B = 0
for i in S:
if i == "A":
A += 1
elif i == "B":
B += 1
if A == 3 or B == 3:
print("No")
else:
print("Yes")
|
S = eval(input())
if S == "AAA" or S == "BBB":
print("No")
else:
print("Yes")
| false
| 61.538462
|
[
"-A = 0",
"-B = 0",
"-for i in S:",
"- if i == \"A\":",
"- A += 1",
"- elif i == \"B\":",
"- B += 1",
"-if A == 3 or B == 3:",
"+if S == \"AAA\" or S == \"BBB\":"
] | false
| 0.116739
| 0.03792
| 3.07852
|
[
"s474803876",
"s986186045"
] |
u630511239
|
p02983
|
python
|
s071375436
|
s727121197
| 237
| 54
| 9,120
| 9,176
|
Accepted
|
Accepted
| 77.22
|
L, R = list(map(int, input().split()))
if R - L >= 2019:
ans = 0
else:
ans = 2018
for i in range(L, R):
for j in range(i + 1, R + 1):
a = (i * j) % 2019
if ans > a:
ans = a
if ans == 1:
break
print(ans)
|
L, R = list(map(int, input().split()))
ans = 2018
for i in range(L, R):
for j in range(i + 1, R + 1):
a = (i * j) % 2019
if a < ans:
ans = a
if ans == 0:
break
else:
continue
break
print(ans)
| 13
| 14
| 296
| 279
|
L, R = list(map(int, input().split()))
if R - L >= 2019:
ans = 0
else:
ans = 2018
for i in range(L, R):
for j in range(i + 1, R + 1):
a = (i * j) % 2019
if ans > a:
ans = a
if ans == 1:
break
print(ans)
|
L, R = list(map(int, input().split()))
ans = 2018
for i in range(L, R):
for j in range(i + 1, R + 1):
a = (i * j) % 2019
if a < ans:
ans = a
if ans == 0:
break
else:
continue
break
print(ans)
| false
| 7.142857
|
[
"-if R - L >= 2019:",
"- ans = 0",
"-else:",
"- ans = 2018",
"- for i in range(L, R):",
"- for j in range(i + 1, R + 1):",
"- a = (i * j) % 2019",
"- if ans > a:",
"- ans = a",
"- if ans == 1:",
"- break",
"+ans = 2018",
"+for i in range(L, R):",
"+ for j in range(i + 1, R + 1):",
"+ a = (i * j) % 2019",
"+ if a < ans:",
"+ ans = a",
"+ if ans == 0:",
"+ break",
"+ else:",
"+ continue",
"+ break"
] | false
| 0.04655
| 0.043326
| 1.074402
|
[
"s071375436",
"s727121197"
] |
u363407238
|
p03325
|
python
|
s831241573
|
s325804960
| 114
| 95
| 4,148
| 4,276
|
Accepted
|
Accepted
| 16.67
|
n = int(eval(input()))
a = list(map(int, input().split()))
ans = 0
def d(ai,ans):
if ai % 2 != 0:
return ans
ans += 1
return d(ai / 2, ans)
for ai in a:
ans=d(ai,ans)
print(ans)
|
N=int(eval(input()))
A=list(map(int,input().split()))
count=0
for a in A:
while a%2==0:
count+=1
a//=2
print(count)
| 16
| 8
| 216
| 136
|
n = int(eval(input()))
a = list(map(int, input().split()))
ans = 0
def d(ai, ans):
if ai % 2 != 0:
return ans
ans += 1
return d(ai / 2, ans)
for ai in a:
ans = d(ai, ans)
print(ans)
|
N = int(eval(input()))
A = list(map(int, input().split()))
count = 0
for a in A:
while a % 2 == 0:
count += 1
a //= 2
print(count)
| false
| 50
|
[
"-n = int(eval(input()))",
"-a = list(map(int, input().split()))",
"-ans = 0",
"-",
"-",
"-def d(ai, ans):",
"- if ai % 2 != 0:",
"- return ans",
"- ans += 1",
"- return d(ai / 2, ans)",
"-",
"-",
"-for ai in a:",
"- ans = d(ai, ans)",
"-print(ans)",
"+N = int(eval(input()))",
"+A = list(map(int, input().split()))",
"+count = 0",
"+for a in A:",
"+ while a % 2 == 0:",
"+ count += 1",
"+ a //= 2",
"+print(count)"
] | false
| 0.045674
| 0.086232
| 0.529672
|
[
"s831241573",
"s325804960"
] |
u806976856
|
p02912
|
python
|
s271826024
|
s363489356
| 166
| 140
| 86,160
| 87,200
|
Accepted
|
Accepted
| 15.66
|
import sys
input=sys.stdin.readline #文字列入力はするな！！
import heapq
n,m=list(map(int,input().split()))
a=list(map(int,input().split()))
for i in range(n):
a[i]*=-1
heapq.heapify(a)
for i in range(m):
h=-heapq.heappop(a)
h=h//2
heapq.heappush(a,-h)
print((-sum(a)))
|
import sys
input=sys.stdin.readline #文字列入力はするな！！
import heapq
n,m=list(map(int,input().split()))
a=list(map(int,input().split()))
for i in range(n):
a[i]*=-1
a=sorted(a)
for i in range(m):
h=-heapq.heappop(a)
h=h//2
heapq.heappush(a,-h)
print((-sum(a)))
| 14
| 14
| 281
| 276
|
import sys
input = sys.stdin.readline # 文字列入力はするな！！
import heapq
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
for i in range(n):
a[i] *= -1
heapq.heapify(a)
for i in range(m):
h = -heapq.heappop(a)
h = h // 2
heapq.heappush(a, -h)
print((-sum(a)))
|
import sys
input = sys.stdin.readline # 文字列入力はするな！！
import heapq
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
for i in range(n):
a[i] *= -1
a = sorted(a)
for i in range(m):
h = -heapq.heappop(a)
h = h // 2
heapq.heappush(a, -h)
print((-sum(a)))
| false
| 0
|
[
"-heapq.heapify(a)",
"+a = sorted(a)"
] | false
| 0.041011
| 0.051811
| 0.791539
|
[
"s271826024",
"s363489356"
] |
u519968172
|
p03274
|
python
|
s456786008
|
s507984248
| 100
| 90
| 20,144
| 20,084
|
Accepted
|
Accepted
| 10
|
n,k=list(map(int,input().split()))
x=list(map(int,input().split()))
import bisect
c=bisect.bisect_left(x,0)
mt=2*10**8
for i in range(n-k+1):
if i+k<c:continue
mt=min(mt,2*abs(x[i])+abs(x[i+k-1]),abs(x[i])+2*abs(x[i+k-1]))
if i+k-1 ==c-1:mt=min(mt,abs(x[i]))
if i==c:mt=min(mt,x[i+k-1])
if n==k:
if c!=n and c!=0:
mt=min(2*abs(x[0])+x[-1],2*x[-1]+abs(x[0]))
else:
mt=max(abs(x[0]),abs(x[-1]))
print(mt)
|
n,k=list(map(int,input().split()))
x=list(map(int,input().split()))
mt=5*10**8
for i in range(n-k+1):
mt=min(mt,2*abs(x[i])+abs(x[i+k-1]),abs(x[i])+2*abs(x[i+k-1]))
if x[0]>0:mt=min(mt,x[k-1])
elif x[-1]<0:mt=min(mt,abs(x[-1-k+1]))
print(mt)
| 20
| 13
| 445
| 260
|
n, k = list(map(int, input().split()))
x = list(map(int, input().split()))
import bisect
c = bisect.bisect_left(x, 0)
mt = 2 * 10**8
for i in range(n - k + 1):
if i + k < c:
continue
mt = min(mt, 2 * abs(x[i]) + abs(x[i + k - 1]), abs(x[i]) + 2 * abs(x[i + k - 1]))
if i + k - 1 == c - 1:
mt = min(mt, abs(x[i]))
if i == c:
mt = min(mt, x[i + k - 1])
if n == k:
if c != n and c != 0:
mt = min(2 * abs(x[0]) + x[-1], 2 * x[-1] + abs(x[0]))
else:
mt = max(abs(x[0]), abs(x[-1]))
print(mt)
|
n, k = list(map(int, input().split()))
x = list(map(int, input().split()))
mt = 5 * 10**8
for i in range(n - k + 1):
mt = min(mt, 2 * abs(x[i]) + abs(x[i + k - 1]), abs(x[i]) + 2 * abs(x[i + k - 1]))
if x[0] > 0:
mt = min(mt, x[k - 1])
elif x[-1] < 0:
mt = min(mt, abs(x[-1 - k + 1]))
print(mt)
| false
| 35
|
[
"-import bisect",
"-",
"-c = bisect.bisect_left(x, 0)",
"-mt = 2 * 10**8",
"+mt = 5 * 10**8",
"- if i + k < c:",
"- continue",
"- if i + k - 1 == c - 1:",
"- mt = min(mt, abs(x[i]))",
"- if i == c:",
"- mt = min(mt, x[i + k - 1])",
"-if n == k:",
"- if c != n and c != 0:",
"- mt = min(2 * abs(x[0]) + x[-1], 2 * x[-1] + abs(x[0]))",
"- else:",
"- mt = max(abs(x[0]), abs(x[-1]))",
"+if x[0] > 0:",
"+ mt = min(mt, x[k - 1])",
"+elif x[-1] < 0:",
"+ mt = min(mt, abs(x[-1 - k + 1]))"
] | false
| 0.007623
| 0.038024
| 0.200467
|
[
"s456786008",
"s507984248"
] |
u017415492
|
p03379
|
python
|
s273692715
|
s666956796
| 319
| 190
| 26,180
| 30,832
|
Accepted
|
Accepted
| 40.44
|
n=int(eval(input()))
x=list(map(int,input().split()))
d=sorted(x)
b1=d[len(x)//2-1]
b2=d[len(x)//2]
for i in x:
if i<=b1:
print(b2)
elif i>=b2:
print(b1)
|
n=int(eval(input()))
x=list(map(int,input().split()))
ans=sorted(x)
ans2=ans[n//2-1]
ans1=ans[n//2]
for i in range(n):
if x[i]>=ans[n//2]:
print(ans2)
else:
print(ans1)
| 11
| 12
| 171
| 191
|
n = int(eval(input()))
x = list(map(int, input().split()))
d = sorted(x)
b1 = d[len(x) // 2 - 1]
b2 = d[len(x) // 2]
for i in x:
if i <= b1:
print(b2)
elif i >= b2:
print(b1)
|
n = int(eval(input()))
x = list(map(int, input().split()))
ans = sorted(x)
ans2 = ans[n // 2 - 1]
ans1 = ans[n // 2]
for i in range(n):
if x[i] >= ans[n // 2]:
print(ans2)
else:
print(ans1)
| false
| 8.333333
|
[
"-d = sorted(x)",
"-b1 = d[len(x) // 2 - 1]",
"-b2 = d[len(x) // 2]",
"-for i in x:",
"- if i <= b1:",
"- print(b2)",
"- elif i >= b2:",
"- print(b1)",
"+ans = sorted(x)",
"+ans2 = ans[n // 2 - 1]",
"+ans1 = ans[n // 2]",
"+for i in range(n):",
"+ if x[i] >= ans[n // 2]:",
"+ print(ans2)",
"+ else:",
"+ print(ans1)"
] | false
| 0.038081
| 0.037651
| 1.011429
|
[
"s273692715",
"s666956796"
] |
u043048943
|
p02960
|
python
|
s809192506
|
s837509510
| 956
| 664
| 143,300
| 61,404
|
Accepted
|
Accepted
| 30.54
|
import sys
sys.setrecursionlimit(2**31-1)
input = sys.stdin.readline
write = sys.stdout.write
LMIIS = lambda : list(map(int,input().split()))
II = lambda : int(input())
dbg = lambda *something : print(*something) if DEBUG is True else 0
DEBUG = True
MOD = 10**9 + 7
class ModInt:
def __init__(self, x):
self.x = x.x if isinstance(x, ModInt) else x % MOD
__str__ = lambda self:str(self.x)
__repr__ = __str__
__int__ = lambda self: self.x
__index__ = __int__
__add__ = lambda self, other: ModInt(self.x + ModInt(other).x)
__sub__ = lambda self, other: ModInt(self.x - ModInt(other).x)
__mul__ = lambda self, other: ModInt(self.x * ModInt(other).x)
__pow__ = lambda self, other: ModInt(pow(self.x, ModInt(other).x, MOD))
__mod__ = lambda self, other: ModInt(self.x % ModInt(other).x)
__truediv__ = lambda self, other: ModInt(self.x * pow(ModInt(other).x, MOD - 2, MOD))
__floordiv__ = lambda self, other: ModInt(self.x // ModInt(other).x)
__radd__ = lambda self, other: ModInt(other + self.x)
__rsub__ = lambda self, other: ModInt(other - self.x)
__rpow__ = lambda self, other: ModInt(pow(other, self.x, MOD))
__rmod__ = lambda self, other: ModInt(other % self.x)
__rmul__ = lambda self, other: ModInt(other * self.x)
__rtruediv__ = lambda self, other: ModInt(other * pow(self.x, MOD - 2, MOD))
__rfloordiv__ = lambda self, other: ModInt(other // self.x)
__lt__ = lambda self, other: self.x < ModInt(other).x
__gt__ = lambda self, other: self.x > ModInt(other).x
__le__ = lambda self, other: self.x <= ModInt(other).x
__ge__ = lambda self, other: self.x >= ModInt(other).x
__eq__ = lambda self, other: self.x == ModInt(other).x
__ne__ = lambda self, other: self.x != ModInt(other).x
def main():
S = input()
N = len(S)-1
dp = [[0] * 13 for _ in range(N)]
dp[0] = [ModInt(0) for _ in range(13)]
if S[0] == '?':
for i in range(10):
dp[0][i] = ModInt(1)
else:
dp[0][int(S[0])] = ModInt(1)
for i in range(1,N):
if S[i] == '?':
for j in range(13):
for k in range(10):
dp[i][(j * 10 + k) % 13 ] += dp[i-1][j]
else:
for j in range(13):
dp[i][ (j* 10 + int(S[i])) % 13 ] += dp[i-1][j]
print(dp[len(S)-2][5])
pass
if __name__ == '__main__':
main()
|
import sys
sys.setrecursionlimit(2**31-1)
input = sys.stdin.readline
write = sys.stdout.write
LMIIS = lambda : list(map(int,input().split()))
II = lambda : int(input())
dbg = lambda *something : print(*something) if DEBUG is True else 0
DEBUG = True
MOD = 10**9 + 7
class ModInt:
def __init__(self, x):
self.x = x.x if isinstance(x, ModInt) else x % MOD
__str__ = lambda self:str(self.x)
__repr__ = __str__
__int__ = lambda self: self.x
__index__ = __int__
__add__ = lambda self, other: ModInt(self.x + ModInt(other).x)
__sub__ = lambda self, other: ModInt(self.x - ModInt(other).x)
__mul__ = lambda self, other: ModInt(self.x * ModInt(other).x)
__pow__ = lambda self, other: ModInt(pow(self.x, ModInt(other).x, MOD))
__mod__ = lambda self, other: ModInt(self.x % ModInt(other).x)
__truediv__ = lambda self, other: ModInt(self.x * pow(ModInt(other).x, MOD - 2, MOD))
__floordiv__ = lambda self, other: ModInt(self.x // ModInt(other).x)
__radd__ = lambda self, other: ModInt(other + self.x)
__rsub__ = lambda self, other: ModInt(other - self.x)
__rpow__ = lambda self, other: ModInt(pow(other, self.x, MOD))
__rmod__ = lambda self, other: ModInt(other % self.x)
__rmul__ = lambda self, other: ModInt(other * self.x)
__rtruediv__ = lambda self, other: ModInt(other * pow(self.x, MOD - 2, MOD))
__rfloordiv__ = lambda self, other: ModInt(other // self.x)
__lt__ = lambda self, other: self.x < ModInt(other).x
__gt__ = lambda self, other: self.x > ModInt(other).x
__le__ = lambda self, other: self.x <= ModInt(other).x
__ge__ = lambda self, other: self.x >= ModInt(other).x
__eq__ = lambda self, other: self.x == ModInt(other).x
__ne__ = lambda self, other: self.x != ModInt(other).x
def main():
S = input()
N = len(S)-1
dp = [[0] * 13 for _ in range(N)]
dp[0] = [0 for _ in range(13)]
if S[0] == '?':
for i in range(10):
dp[0][i] = 1
else:
dp[0][int(S[0])] = 1
for i in range(1,N):
if S[i] == '?':
for j in range(13):
for k in range(10):
dp[i][(j * 10 + k) % 13 ] = (dp[i][(j * 10 + k) % 13 ] + dp[i-1][j]) % MOD
else:
for j in range(13):
dp[i][ (j* 10 + int(S[i])) % 13 ] = (dp[i][ (j* 10 + int(S[i])) % 13 ] + dp[i-1][j]) % MOD
print(dp[len(S)-2][5])
pass
if __name__ == '__main__':
main()
| 80
| 80
| 2,518
| 2,573
|
import sys
sys.setrecursionlimit(2**31 - 1)
input = sys.stdin.readline
write = sys.stdout.write
LMIIS = lambda: list(map(int, input().split()))
II = lambda: int(input())
dbg = lambda *something: print(*something) if DEBUG is True else 0
DEBUG = True
MOD = 10**9 + 7
class ModInt:
def __init__(self, x):
self.x = x.x if isinstance(x, ModInt) else x % MOD
__str__ = lambda self: str(self.x)
__repr__ = __str__
__int__ = lambda self: self.x
__index__ = __int__
__add__ = lambda self, other: ModInt(self.x + ModInt(other).x)
__sub__ = lambda self, other: ModInt(self.x - ModInt(other).x)
__mul__ = lambda self, other: ModInt(self.x * ModInt(other).x)
__pow__ = lambda self, other: ModInt(pow(self.x, ModInt(other).x, MOD))
__mod__ = lambda self, other: ModInt(self.x % ModInt(other).x)
__truediv__ = lambda self, other: ModInt(
self.x * pow(ModInt(other).x, MOD - 2, MOD)
)
__floordiv__ = lambda self, other: ModInt(self.x // ModInt(other).x)
__radd__ = lambda self, other: ModInt(other + self.x)
__rsub__ = lambda self, other: ModInt(other - self.x)
__rpow__ = lambda self, other: ModInt(pow(other, self.x, MOD))
__rmod__ = lambda self, other: ModInt(other % self.x)
__rmul__ = lambda self, other: ModInt(other * self.x)
__rtruediv__ = lambda self, other: ModInt(other * pow(self.x, MOD - 2, MOD))
__rfloordiv__ = lambda self, other: ModInt(other // self.x)
__lt__ = lambda self, other: self.x < ModInt(other).x
__gt__ = lambda self, other: self.x > ModInt(other).x
__le__ = lambda self, other: self.x <= ModInt(other).x
__ge__ = lambda self, other: self.x >= ModInt(other).x
__eq__ = lambda self, other: self.x == ModInt(other).x
__ne__ = lambda self, other: self.x != ModInt(other).x
def main():
S = input()
N = len(S) - 1
dp = [[0] * 13 for _ in range(N)]
dp[0] = [ModInt(0) for _ in range(13)]
if S[0] == "?":
for i in range(10):
dp[0][i] = ModInt(1)
else:
dp[0][int(S[0])] = ModInt(1)
for i in range(1, N):
if S[i] == "?":
for j in range(13):
for k in range(10):
dp[i][(j * 10 + k) % 13] += dp[i - 1][j]
else:
for j in range(13):
dp[i][(j * 10 + int(S[i])) % 13] += dp[i - 1][j]
print(dp[len(S) - 2][5])
pass
if __name__ == "__main__":
main()
|
import sys
sys.setrecursionlimit(2**31 - 1)
input = sys.stdin.readline
write = sys.stdout.write
LMIIS = lambda: list(map(int, input().split()))
II = lambda: int(input())
dbg = lambda *something: print(*something) if DEBUG is True else 0
DEBUG = True
MOD = 10**9 + 7
class ModInt:
def __init__(self, x):
self.x = x.x if isinstance(x, ModInt) else x % MOD
__str__ = lambda self: str(self.x)
__repr__ = __str__
__int__ = lambda self: self.x
__index__ = __int__
__add__ = lambda self, other: ModInt(self.x + ModInt(other).x)
__sub__ = lambda self, other: ModInt(self.x - ModInt(other).x)
__mul__ = lambda self, other: ModInt(self.x * ModInt(other).x)
__pow__ = lambda self, other: ModInt(pow(self.x, ModInt(other).x, MOD))
__mod__ = lambda self, other: ModInt(self.x % ModInt(other).x)
__truediv__ = lambda self, other: ModInt(
self.x * pow(ModInt(other).x, MOD - 2, MOD)
)
__floordiv__ = lambda self, other: ModInt(self.x // ModInt(other).x)
__radd__ = lambda self, other: ModInt(other + self.x)
__rsub__ = lambda self, other: ModInt(other - self.x)
__rpow__ = lambda self, other: ModInt(pow(other, self.x, MOD))
__rmod__ = lambda self, other: ModInt(other % self.x)
__rmul__ = lambda self, other: ModInt(other * self.x)
__rtruediv__ = lambda self, other: ModInt(other * pow(self.x, MOD - 2, MOD))
__rfloordiv__ = lambda self, other: ModInt(other // self.x)
__lt__ = lambda self, other: self.x < ModInt(other).x
__gt__ = lambda self, other: self.x > ModInt(other).x
__le__ = lambda self, other: self.x <= ModInt(other).x
__ge__ = lambda self, other: self.x >= ModInt(other).x
__eq__ = lambda self, other: self.x == ModInt(other).x
__ne__ = lambda self, other: self.x != ModInt(other).x
def main():
S = input()
N = len(S) - 1
dp = [[0] * 13 for _ in range(N)]
dp[0] = [0 for _ in range(13)]
if S[0] == "?":
for i in range(10):
dp[0][i] = 1
else:
dp[0][int(S[0])] = 1
for i in range(1, N):
if S[i] == "?":
for j in range(13):
for k in range(10):
dp[i][(j * 10 + k) % 13] = (
dp[i][(j * 10 + k) % 13] + dp[i - 1][j]
) % MOD
else:
for j in range(13):
dp[i][(j * 10 + int(S[i])) % 13] = (
dp[i][(j * 10 + int(S[i])) % 13] + dp[i - 1][j]
) % MOD
print(dp[len(S) - 2][5])
pass
if __name__ == "__main__":
main()
| false
| 0
|
[
"- dp[0] = [ModInt(0) for _ in range(13)]",
"+ dp[0] = [0 for _ in range(13)]",
"- dp[0][i] = ModInt(1)",
"+ dp[0][i] = 1",
"- dp[0][int(S[0])] = ModInt(1)",
"+ dp[0][int(S[0])] = 1",
"- dp[i][(j * 10 + k) % 13] += dp[i - 1][j]",
"+ dp[i][(j * 10 + k) % 13] = (",
"+ dp[i][(j * 10 + k) % 13] + dp[i - 1][j]",
"+ ) % MOD",
"- dp[i][(j * 10 + int(S[i])) % 13] += dp[i - 1][j]",
"+ dp[i][(j * 10 + int(S[i])) % 13] = (",
"+ dp[i][(j * 10 + int(S[i])) % 13] + dp[i - 1][j]",
"+ ) % MOD"
] | false
| 0.007335
| 0.037964
| 0.19321
|
[
"s809192506",
"s837509510"
] |
u465699806
|
p03401
|
python
|
s869746759
|
s057220378
| 1,123
| 531
| 19,652
| 16,564
|
Accepted
|
Accepted
| 52.72
|
import itertools as it
import collections as col
import heapq as hq
import sys
import copy as cp
sys.setrecursionlimit(10**9)
input = sys.stdin.readline
def dump(*objects):
print(*objects, file=sys.stderr)
N = int(input())
A = [0] + list(map(int, input().split())) + [0]
dump(N, A)
B = cp.deepcopy(A)
C = cp.deepcopy(A)
for i in range(1, len(A)):
dump(i)
B[i] = B[i-1] + abs(A[i]-A[i-1])
for i in range(len(A)-2, -1, -1):
dump(i)
C[i] = C[i+1] + abs(A[i]-A[i+1])
dump(A, B, C)
for i in range(1, N+1):
dump(i, B[i-1] + B[N+1] - B[i+1] + abs(A[i-1]-A[i+1]))
print(B[i-1] + C[i+1] + abs(A[i-1]-A[i+1]))
exit(0)
|
import itertools as it
import collections as col
import heapq as hq
import sys
import copy as cp
sys.setrecursionlimit(10**9)
args = sys.argv
input = sys.stdin.readline
def dump(*objects):
if len(args) == 2 and args[1] == "DEBUG":
print(*objects, file=sys.stderr)
N = int(input())
A = [0] + list(map(int, input().split())) + [0]
dump(N, A)
B = cp.deepcopy(A)
C = cp.deepcopy(A)
for i in range(1, len(A)):
dump(i)
B[i] = B[i - 1] + abs(A[i] - A[i - 1])
for i in range(len(A) - 2, -1, -1):
dump(i)
C[i] = C[i+1] + abs(A[i]-A[i+1])
dump(A, B, C)
for i in range(1, N+1):
dump(i, B[i-1] + B[N+1] - B[i+1] + abs(A[i-1]-A[i+1]))
print(B[i-1] + C[i+1] + abs(A[i-1]-A[i+1]))
exit(0)
| 30
| 32
| 670
| 746
|
import itertools as it
import collections as col
import heapq as hq
import sys
import copy as cp
sys.setrecursionlimit(10**9)
input = sys.stdin.readline
def dump(*objects):
print(*objects, file=sys.stderr)
N = int(input())
A = [0] + list(map(int, input().split())) + [0]
dump(N, A)
B = cp.deepcopy(A)
C = cp.deepcopy(A)
for i in range(1, len(A)):
dump(i)
B[i] = B[i - 1] + abs(A[i] - A[i - 1])
for i in range(len(A) - 2, -1, -1):
dump(i)
C[i] = C[i + 1] + abs(A[i] - A[i + 1])
dump(A, B, C)
for i in range(1, N + 1):
dump(i, B[i - 1] + B[N + 1] - B[i + 1] + abs(A[i - 1] - A[i + 1]))
print(B[i - 1] + C[i + 1] + abs(A[i - 1] - A[i + 1]))
exit(0)
|
import itertools as it
import collections as col
import heapq as hq
import sys
import copy as cp
sys.setrecursionlimit(10**9)
args = sys.argv
input = sys.stdin.readline
def dump(*objects):
if len(args) == 2 and args[1] == "DEBUG":
print(*objects, file=sys.stderr)
N = int(input())
A = [0] + list(map(int, input().split())) + [0]
dump(N, A)
B = cp.deepcopy(A)
C = cp.deepcopy(A)
for i in range(1, len(A)):
dump(i)
B[i] = B[i - 1] + abs(A[i] - A[i - 1])
for i in range(len(A) - 2, -1, -1):
dump(i)
C[i] = C[i + 1] + abs(A[i] - A[i + 1])
dump(A, B, C)
for i in range(1, N + 1):
dump(i, B[i - 1] + B[N + 1] - B[i + 1] + abs(A[i - 1] - A[i + 1]))
print(B[i - 1] + C[i + 1] + abs(A[i - 1] - A[i + 1]))
exit(0)
| false
| 6.25
|
[
"+args = sys.argv",
"- print(*objects, file=sys.stderr)",
"+ if len(args) == 2 and args[1] == \"DEBUG\":",
"+ print(*objects, file=sys.stderr)"
] | false
| 0.04836
| 0.050103
| 0.965205
|
[
"s869746759",
"s057220378"
] |
u141610915
|
p02960
|
python
|
s522235731
|
s440642924
| 1,302
| 774
| 66,840
| 66,872
|
Accepted
|
Accepted
| 40.55
|
import sys
input = sys.stdin.readline
S = list(eval(input()))[: -1]
K = 13
mod = 10 ** 9 + 7
dp = [[0] * (K) for _ in range(len(S) + 1)]
dp[0][0] = 1
for i in range(len(S)):
for j in range(K):
for k in range(10):
if S[i] == "?":
dp[i + 1][(j * 10 + k) % K] += dp[i][j]
dp[i + 1][(j * 10 + k) % K] %= mod
elif int(S[i]) == k:
dp[i + 1][(j * 10 + k) % K] += dp[i][j]
dp[i + 1][(j * 10 + k) % K] %= mod
print((dp[-1][5]))
|
import sys
input = sys.stdin.readline
S = list(eval(input()))[: -1]
mod = 10 ** 9 + 7
N = len(S)
dp = [[0] * 13 for _ in range(N + 1)]
dp[0][0] = 1
for i in range(N):
for j in range(13):
if S[i] != "?":
x = int(S[i])
dp[i + 1][(j * 10 + x) % 13] += dp[i][j]
dp[i + 1][(j * 10 + x) % 13] %= mod
else:
for x in range(10):
dp[i + 1][(j * 10 + x) % 13] += dp[i][j]
dp[i + 1][(j * 10 + x) % 13] %= mod
print((dp[-1][5]))
| 17
| 18
| 476
| 474
|
import sys
input = sys.stdin.readline
S = list(eval(input()))[:-1]
K = 13
mod = 10**9 + 7
dp = [[0] * (K) for _ in range(len(S) + 1)]
dp[0][0] = 1
for i in range(len(S)):
for j in range(K):
for k in range(10):
if S[i] == "?":
dp[i + 1][(j * 10 + k) % K] += dp[i][j]
dp[i + 1][(j * 10 + k) % K] %= mod
elif int(S[i]) == k:
dp[i + 1][(j * 10 + k) % K] += dp[i][j]
dp[i + 1][(j * 10 + k) % K] %= mod
print((dp[-1][5]))
|
import sys
input = sys.stdin.readline
S = list(eval(input()))[:-1]
mod = 10**9 + 7
N = len(S)
dp = [[0] * 13 for _ in range(N + 1)]
dp[0][0] = 1
for i in range(N):
for j in range(13):
if S[i] != "?":
x = int(S[i])
dp[i + 1][(j * 10 + x) % 13] += dp[i][j]
dp[i + 1][(j * 10 + x) % 13] %= mod
else:
for x in range(10):
dp[i + 1][(j * 10 + x) % 13] += dp[i][j]
dp[i + 1][(j * 10 + x) % 13] %= mod
print((dp[-1][5]))
| false
| 5.555556
|
[
"-K = 13",
"-dp = [[0] * (K) for _ in range(len(S) + 1)]",
"+N = len(S)",
"+dp = [[0] * 13 for _ in range(N + 1)]",
"-for i in range(len(S)):",
"- for j in range(K):",
"- for k in range(10):",
"- if S[i] == \"?\":",
"- dp[i + 1][(j * 10 + k) % K] += dp[i][j]",
"- dp[i + 1][(j * 10 + k) % K] %= mod",
"- elif int(S[i]) == k:",
"- dp[i + 1][(j * 10 + k) % K] += dp[i][j]",
"- dp[i + 1][(j * 10 + k) % K] %= mod",
"+for i in range(N):",
"+ for j in range(13):",
"+ if S[i] != \"?\":",
"+ x = int(S[i])",
"+ dp[i + 1][(j * 10 + x) % 13] += dp[i][j]",
"+ dp[i + 1][(j * 10 + x) % 13] %= mod",
"+ else:",
"+ for x in range(10):",
"+ dp[i + 1][(j * 10 + x) % 13] += dp[i][j]",
"+ dp[i + 1][(j * 10 + x) % 13] %= mod"
] | false
| 0.034507
| 0.083325
| 0.41413
|
[
"s522235731",
"s440642924"
] |
u699944218
|
p02695
|
python
|
s793438934
|
s766235587
| 960
| 576
| 9,156
| 9,164
|
Accepted
|
Accepted
| 40
|
n,m,q=list(map(int,input().split()))
arr=[list(map(int,input().split())) for _ in range(q)]
ans=0
for i1 in range(1,m+1): #愚直に10重ループを行っても、そのループ回数は高々92378回
for i2 in range(i1,m+1):
for i3 in range(i2,m+1):
for i4 in range(i3,m+1):
for i5 in range(i4,m+1):
for i6 in range(i5,m+1):
for i7 in range(i6,m+1):
for i8 in range(i7,m+1):
for i9 in range(i8,m+1):
for i10 in range(i9,m+1):
tmp=0
arrs=[0,i1,i2,i3,i4,i5,i6,i7,i8,i9,i10]
for a,b,c,d in arr: #条件を満たす数列について、最大値を求める
if arrs[b]-arrs[a]==c:
tmp+=d
ans=max(ans,tmp)
print(ans)
|
# 入力
N, M, Q = list(map(int, input().split()))
a = [0] * Q
b = [0] * Q
c = [0] * Q
d = [0] * Q
for i in range(Q):
a[i], b[i], c[i], d[i] = list(map(int, input().split()))
a[i] -= 1
b[i] -= 1
# スコア計算
def score(A):
tmp = 0
for ai, bi, ci, di in zip(a, b, c, d):
if A[bi] - A[ai] == ci:
tmp += di
return tmp
# DFS
def dfs(A):
if len(A) == N:
return score(A) # 数列 A のスコアを返す
res = 0
prev_last = A[-1] if len(A) > 0 else 0
for v in range(prev_last, M):
A.append(v)
res = max(res, dfs(A)) # 再帰呼出しながら、スコア最大値も更新
A.pop()
return res
# 求める
print((dfs([])))
| 20
| 33
| 755
| 661
|
n, m, q = list(map(int, input().split()))
arr = [list(map(int, input().split())) for _ in range(q)]
ans = 0
for i1 in range(1, m + 1): # 愚直に10重ループを行っても、そのループ回数は高々92378回
for i2 in range(i1, m + 1):
for i3 in range(i2, m + 1):
for i4 in range(i3, m + 1):
for i5 in range(i4, m + 1):
for i6 in range(i5, m + 1):
for i7 in range(i6, m + 1):
for i8 in range(i7, m + 1):
for i9 in range(i8, m + 1):
for i10 in range(i9, m + 1):
tmp = 0
arrs = [
0,
i1,
i2,
i3,
i4,
i5,
i6,
i7,
i8,
i9,
i10,
]
for a, b, c, d in arr: # 条件を満たす数列について、最大値を求める
if arrs[b] - arrs[a] == c:
tmp += d
ans = max(ans, tmp)
print(ans)
|
# 入力
N, M, Q = list(map(int, input().split()))
a = [0] * Q
b = [0] * Q
c = [0] * Q
d = [0] * Q
for i in range(Q):
a[i], b[i], c[i], d[i] = list(map(int, input().split()))
a[i] -= 1
b[i] -= 1
# スコア計算
def score(A):
tmp = 0
for ai, bi, ci, di in zip(a, b, c, d):
if A[bi] - A[ai] == ci:
tmp += di
return tmp
# DFS
def dfs(A):
if len(A) == N:
return score(A) # 数列 A のスコアを返す
res = 0
prev_last = A[-1] if len(A) > 0 else 0
for v in range(prev_last, M):
A.append(v)
res = max(res, dfs(A)) # 再帰呼出しながら、スコア最大値も更新
A.pop()
return res
# 求める
print((dfs([])))
| false
| 39.393939
|
[
"-n, m, q = list(map(int, input().split()))",
"-arr = [list(map(int, input().split())) for _ in range(q)]",
"-ans = 0",
"-for i1 in range(1, m + 1): # 愚直に10重ループを行っても、そのループ回数は高々92378回",
"- for i2 in range(i1, m + 1):",
"- for i3 in range(i2, m + 1):",
"- for i4 in range(i3, m + 1):",
"- for i5 in range(i4, m + 1):",
"- for i6 in range(i5, m + 1):",
"- for i7 in range(i6, m + 1):",
"- for i8 in range(i7, m + 1):",
"- for i9 in range(i8, m + 1):",
"- for i10 in range(i9, m + 1):",
"- tmp = 0",
"- arrs = [",
"- 0,",
"- i1,",
"- i2,",
"- i3,",
"- i4,",
"- i5,",
"- i6,",
"- i7,",
"- i8,",
"- i9,",
"- i10,",
"- ]",
"- for a, b, c, d in arr: # 条件を満たす数列について、最大値を求める",
"- if arrs[b] - arrs[a] == c:",
"- tmp += d",
"- ans = max(ans, tmp)",
"-print(ans)",
"+# 入力",
"+N, M, Q = list(map(int, input().split()))",
"+a = [0] * Q",
"+b = [0] * Q",
"+c = [0] * Q",
"+d = [0] * Q",
"+for i in range(Q):",
"+ a[i], b[i], c[i], d[i] = list(map(int, input().split()))",
"+ a[i] -= 1",
"+ b[i] -= 1",
"+# スコア計算",
"+def score(A):",
"+ tmp = 0",
"+ for ai, bi, ci, di in zip(a, b, c, d):",
"+ if A[bi] - A[ai] == ci:",
"+ tmp += di",
"+ return tmp",
"+",
"+",
"+# DFS",
"+def dfs(A):",
"+ if len(A) == N:",
"+ return score(A) # 数列 A のスコアを返す",
"+ res = 0",
"+ prev_last = A[-1] if len(A) > 0 else 0",
"+ for v in range(prev_last, M):",
"+ A.append(v)",
"+ res = max(res, dfs(A)) # 再帰呼出しながら、スコア最大値も更新",
"+ A.pop()",
"+ return res",
"+",
"+",
"+# 求める",
"+print((dfs([])))"
] | false
| 0.202976
| 0.070773
| 2.867974
|
[
"s793438934",
"s766235587"
] |
u203669169
|
p02712
|
python
|
s193547971
|
s114464453
| 170
| 119
| 10,392
| 31,136
|
Accepted
|
Accepted
| 30
|
#! /usr/bin/env python3
from fractions import gcd
from collections import Counter, deque, defaultdict
from heapq import heappush, heappop, heappushpop, heapify, heapreplace, merge
from bisect import bisect_left, bisect_right, bisect, insort_left, insort_right, insort
from itertools import accumulate, product, permutations, combinations, combinations_with_replacement
N = int(eval(input()))
ret = 0
for i in range(1, N+1):
if i % 3 == 0 or i % 5 == 0:
continue
ret += i
print(ret)
|
#! /usr/bin/env python3
from fractions import gcd
from collections import Counter, deque, defaultdict
from heapq import heappush, heappop, heappushpop, heapify, heapreplace, merge
from bisect import bisect_left, bisect_right, bisect, insort_left, insort_right, insort
from itertools import accumulate, product, permutations, combinations, combinations_with_replacement
N = int(eval(input()))
ret = sum([i for i in range(1, N+1) if not (i % 3 == 0 or i % 5 == 0)])
print(ret)
| 15
| 11
| 507
| 480
|
#! /usr/bin/env python3
from fractions import gcd
from collections import Counter, deque, defaultdict
from heapq import heappush, heappop, heappushpop, heapify, heapreplace, merge
from bisect import bisect_left, bisect_right, bisect, insort_left, insort_right, insort
from itertools import (
accumulate,
product,
permutations,
combinations,
combinations_with_replacement,
)
N = int(eval(input()))
ret = 0
for i in range(1, N + 1):
if i % 3 == 0 or i % 5 == 0:
continue
ret += i
print(ret)
|
#! /usr/bin/env python3
from fractions import gcd
from collections import Counter, deque, defaultdict
from heapq import heappush, heappop, heappushpop, heapify, heapreplace, merge
from bisect import bisect_left, bisect_right, bisect, insort_left, insort_right, insort
from itertools import (
accumulate,
product,
permutations,
combinations,
combinations_with_replacement,
)
N = int(eval(input()))
ret = sum([i for i in range(1, N + 1) if not (i % 3 == 0 or i % 5 == 0)])
print(ret)
| false
| 26.666667
|
[
"-ret = 0",
"-for i in range(1, N + 1):",
"- if i % 3 == 0 or i % 5 == 0:",
"- continue",
"- ret += i",
"+ret = sum([i for i in range(1, N + 1) if not (i % 3 == 0 or i % 5 == 0)])"
] | false
| 0.199612
| 0.115662
| 1.725829
|
[
"s193547971",
"s114464453"
] |
u112364985
|
p02657
|
python
|
s993562618
|
s756229552
| 60
| 28
| 61,720
| 9,084
|
Accepted
|
Accepted
| 53.33
|
a,b=list(map(int,input().split()))
print((a*b))
|
def resolve():
a,b=list(map(int,input().split()))
print((a*b))
resolve()
| 2
| 4
| 40
| 69
|
a, b = list(map(int, input().split()))
print((a * b))
|
def resolve():
a, b = list(map(int, input().split()))
print((a * b))
resolve()
| false
| 50
|
[
"-a, b = list(map(int, input().split()))",
"-print((a * b))",
"+def resolve():",
"+ a, b = list(map(int, input().split()))",
"+ print((a * b))",
"+",
"+",
"+resolve()"
] | false
| 0.055385
| 0.041389
| 1.338162
|
[
"s993562618",
"s756229552"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.