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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
u799428010
|
p02812
|
python
|
s483202510
|
s686951165
| 31 | 27 | 9,152 | 9,148 |
Accepted
|
Accepted
| 12.9 |
N=int(eval(input()))
S=str(eval(input()))
print((S.count('ABC')))
|
N=int(eval(input()))
print((str(eval(input())).count('ABC')))
| 3 | 2 | 53 | 48 |
N = int(eval(input()))
S = str(eval(input()))
print((S.count("ABC")))
|
N = int(eval(input()))
print((str(eval(input())).count("ABC")))
| false | 33.333333 |
[
"-S = str(eval(input()))",
"-print((S.count(\"ABC\")))",
"+print((str(eval(input())).count(\"ABC\")))"
] | false | 0.049042 | 0.037617 | 1.303719 |
[
"s483202510",
"s686951165"
] |
u624475441
|
p03310
|
python
|
s307730648
|
s301726958
| 777 | 702 | 25,972 | 25,972 |
Accepted
|
Accepted
| 9.65 |
from itertools import *
n=int(eval(input()))
sumA=[0]+list(accumulate(list(map(int,input().split()))))
def check(l,m,r):
if m==r:return False
tmp=sumA[r]+sumA[l]
return abs(tmp-sumA[m+1]*2)<abs(tmp-sumA[m]*2)
res=float('inf')
li,ri=1,3
for mid in range(2,n-1):
while check(0,li,mid):li+=1
while check(mid,ri,n):ri+=1
x=sorted([sumA[li],sumA[mid]-sumA[li],sumA[ri]-sumA[mid],sumA[n]-sumA[ri]])
tmp=x[3]-x[0]
if tmp<res:res=tmp
print(res)
|
from itertools import *
eval(input())
s=list(accumulate(list(map(int,input().split()))))
l,r,t=0,2,s[-1];a=t
for m in s[1:-2]:
while abs(t-2*s[r]+m)>abs(t-2*s[r+1]+m):r+=1
while abs(m-2*s[l])>abs(m-2*s[l+1]):l+=1
x=sorted([s[l],m-s[l],s[r]-m,t-s[r]])
a=min(a,x[3]-x[0])
print(a)
| 16 | 10 | 471 | 291 |
from itertools import *
n = int(eval(input()))
sumA = [0] + list(accumulate(list(map(int, input().split()))))
def check(l, m, r):
if m == r:
return False
tmp = sumA[r] + sumA[l]
return abs(tmp - sumA[m + 1] * 2) < abs(tmp - sumA[m] * 2)
res = float("inf")
li, ri = 1, 3
for mid in range(2, n - 1):
while check(0, li, mid):
li += 1
while check(mid, ri, n):
ri += 1
x = sorted(
[sumA[li], sumA[mid] - sumA[li], sumA[ri] - sumA[mid], sumA[n] - sumA[ri]]
)
tmp = x[3] - x[0]
if tmp < res:
res = tmp
print(res)
|
from itertools import *
eval(input())
s = list(accumulate(list(map(int, input().split()))))
l, r, t = 0, 2, s[-1]
a = t
for m in s[1:-2]:
while abs(t - 2 * s[r] + m) > abs(t - 2 * s[r + 1] + m):
r += 1
while abs(m - 2 * s[l]) > abs(m - 2 * s[l + 1]):
l += 1
x = sorted([s[l], m - s[l], s[r] - m, t - s[r]])
a = min(a, x[3] - x[0])
print(a)
| false | 37.5 |
[
"-n = int(eval(input()))",
"-sumA = [0] + list(accumulate(list(map(int, input().split()))))",
"-",
"-",
"-def check(l, m, r):",
"- if m == r:",
"- return False",
"- tmp = sumA[r] + sumA[l]",
"- return abs(tmp - sumA[m + 1] * 2) < abs(tmp - sumA[m] * 2)",
"-",
"-",
"-res = float(\"inf\")",
"-li, ri = 1, 3",
"-for mid in range(2, n - 1):",
"- while check(0, li, mid):",
"- li += 1",
"- while check(mid, ri, n):",
"- ri += 1",
"- x = sorted(",
"- [sumA[li], sumA[mid] - sumA[li], sumA[ri] - sumA[mid], sumA[n] - sumA[ri]]",
"- )",
"- tmp = x[3] - x[0]",
"- if tmp < res:",
"- res = tmp",
"-print(res)",
"+eval(input())",
"+s = list(accumulate(list(map(int, input().split()))))",
"+l, r, t = 0, 2, s[-1]",
"+a = t",
"+for m in s[1:-2]:",
"+ while abs(t - 2 * s[r] + m) > abs(t - 2 * s[r + 1] + m):",
"+ r += 1",
"+ while abs(m - 2 * s[l]) > abs(m - 2 * s[l + 1]):",
"+ l += 1",
"+ x = sorted([s[l], m - s[l], s[r] - m, t - s[r]])",
"+ a = min(a, x[3] - x[0])",
"+print(a)"
] | false | 0.043536 | 0.039716 | 1.096195 |
[
"s307730648",
"s301726958"
] |
u660912567
|
p00722
|
python
|
s262526943
|
s426009008
| 280 | 250 | 14,956 | 15,040 |
Accepted
|
Accepted
| 10.71 |
def isPrime(n):
f = [True]*(n+1)
f[0] = f[1] = False
for i in range(2,int(n**0.5)+1):
if f[i]:
for j in range(i**2, n+1, i): f[j] = False
return f
l = isPrime(1000000)
while True:
a,d,n = list(map(int,input().split()))
if not(n): break
cnt = 0
while True:
if l[a]: cnt += 1
if cnt==n: break
a += d
print(a)
|
def prime(n):
flag = [True]*(n+1)
flag[0] = flag[1] = False
for i in range(2,int(n**0.5)+1):
if flag[i]:
for j in range(i**2, n+1, i):
flag[j] = False
return flag
flag = prime(1000000)
while True:
a,d,n = list(map(int,input().split()))
if n==0: break
i,c = 0,0
while c<n:
if flag[a+d*i]: c+= 1
i += 1
print((a+d*(i-1)))
| 19 | 17 | 404 | 415 |
def isPrime(n):
f = [True] * (n + 1)
f[0] = f[1] = False
for i in range(2, int(n**0.5) + 1):
if f[i]:
for j in range(i**2, n + 1, i):
f[j] = False
return f
l = isPrime(1000000)
while True:
a, d, n = list(map(int, input().split()))
if not (n):
break
cnt = 0
while True:
if l[a]:
cnt += 1
if cnt == n:
break
a += d
print(a)
|
def prime(n):
flag = [True] * (n + 1)
flag[0] = flag[1] = False
for i in range(2, int(n**0.5) + 1):
if flag[i]:
for j in range(i**2, n + 1, i):
flag[j] = False
return flag
flag = prime(1000000)
while True:
a, d, n = list(map(int, input().split()))
if n == 0:
break
i, c = 0, 0
while c < n:
if flag[a + d * i]:
c += 1
i += 1
print((a + d * (i - 1)))
| false | 10.526316 |
[
"-def isPrime(n):",
"- f = [True] * (n + 1)",
"- f[0] = f[1] = False",
"+def prime(n):",
"+ flag = [True] * (n + 1)",
"+ flag[0] = flag[1] = False",
"- if f[i]:",
"+ if flag[i]:",
"- f[j] = False",
"- return f",
"+ flag[j] = False",
"+ return flag",
"-l = isPrime(1000000)",
"+flag = prime(1000000)",
"- if not (n):",
"+ if n == 0:",
"- cnt = 0",
"- while True:",
"- if l[a]:",
"- cnt += 1",
"- if cnt == n:",
"- break",
"- a += d",
"- print(a)",
"+ i, c = 0, 0",
"+ while c < n:",
"+ if flag[a + d * i]:",
"+ c += 1",
"+ i += 1",
"+ print((a + d * (i - 1)))"
] | false | 0.521226 | 0.495517 | 1.051884 |
[
"s262526943",
"s426009008"
] |
u441246928
|
p03636
|
python
|
s908189269
|
s285606721
| 19 | 17 | 3,060 | 2,940 |
Accepted
|
Accepted
| 10.53 |
s = eval(input())
t = 0
for i in range(1,len(s)-1):
t += 1
print((s[0] + str(t) + s[len(s)-1]))
|
s = list(eval(input()))
print((s[0] + str(len(s) - 2 ) + s[-1]))
| 5 | 2 | 95 | 57 |
s = eval(input())
t = 0
for i in range(1, len(s) - 1):
t += 1
print((s[0] + str(t) + s[len(s) - 1]))
|
s = list(eval(input()))
print((s[0] + str(len(s) - 2) + s[-1]))
| false | 60 |
[
"-s = eval(input())",
"-t = 0",
"-for i in range(1, len(s) - 1):",
"- t += 1",
"-print((s[0] + str(t) + s[len(s) - 1]))",
"+s = list(eval(input()))",
"+print((s[0] + str(len(s) - 2) + s[-1]))"
] | false | 0.070353 | 0.050577 | 1.391009 |
[
"s908189269",
"s285606721"
] |
u737758066
|
p02773
|
python
|
s947122931
|
s912679462
| 1,160 | 1,015 | 101,968 | 100,432 |
Accepted
|
Accepted
| 12.5 |
import collections
n = int(eval(input()))
s = [eval(input()) for _ in range(n)]
ss = collections.Counter(s)
# print(ss)
n_ma = max(ss.values())
ans = []
for k in list(ss.keys()):
if ss[k] == n_ma:
ans.append(k)
ans = sorted(ans)
for a in ans:
print(a)
|
import collections
n = int(eval(input()))
si = []
for i in range(n):
si.append(eval(input()))
ss = collections.Counter(si)
n_ma = max(ss.values())
ans = []
for i in list(ss.keys()):
if ss[i] == n_ma:
ans.append(i)
ans.sort()
for i in range(len(ans)):
print((ans[i]))
| 14 | 16 | 264 | 284 |
import collections
n = int(eval(input()))
s = [eval(input()) for _ in range(n)]
ss = collections.Counter(s)
# print(ss)
n_ma = max(ss.values())
ans = []
for k in list(ss.keys()):
if ss[k] == n_ma:
ans.append(k)
ans = sorted(ans)
for a in ans:
print(a)
|
import collections
n = int(eval(input()))
si = []
for i in range(n):
si.append(eval(input()))
ss = collections.Counter(si)
n_ma = max(ss.values())
ans = []
for i in list(ss.keys()):
if ss[i] == n_ma:
ans.append(i)
ans.sort()
for i in range(len(ans)):
print((ans[i]))
| false | 12.5 |
[
"-s = [eval(input()) for _ in range(n)]",
"-ss = collections.Counter(s)",
"-# print(ss)",
"+si = []",
"+for i in range(n):",
"+ si.append(eval(input()))",
"+ss = collections.Counter(si)",
"-for k in list(ss.keys()):",
"- if ss[k] == n_ma:",
"- ans.append(k)",
"-ans = sorted(ans)",
"-for a in ans:",
"- print(a)",
"+for i in list(ss.keys()):",
"+ if ss[i] == n_ma:",
"+ ans.append(i)",
"+ans.sort()",
"+for i in range(len(ans)):",
"+ print((ans[i]))"
] | false | 0.048273 | 0.049038 | 0.984397 |
[
"s947122931",
"s912679462"
] |
u761320129
|
p03435
|
python
|
s071004201
|
s281158821
| 19 | 17 | 3,064 | 3,064 |
Accepted
|
Accepted
| 10.53 |
c1 = list(map(int,input().split()))
c2 = list(map(int,input().split()))
c3 = list(map(int,input().split()))
if not c1[0]-c1[1] == c2[0]-c2[1] == c3[0]-c3[1]:
print('No')
exit()
if not c1[2]-c1[1] == c2[2]-c2[1] == c3[2]-c3[1]:
print('No')
exit()
if not c1[0]-c2[0] == c1[1]-c2[1] == c1[2]-c2[2]:
print('No')
exit()
if not c3[0]-c2[0] == c3[1]-c2[1] == c3[2]-c2[2]:
print('No')
exit()
print('Yes')
|
a1,a2,a3 = list(map(int,input().split()))
b1,b2,b3 = list(map(int,input().split()))
c1,c2,c3 = list(map(int,input().split()))
if not (a1-a2 == b1-b2 == c1-c2) or not (a2-a3 == b2-b3 == c2-c3):
print('No')
elif not (a1-b1 == a2-b2 == a3-b3) or not (b1-c1 == b2-c2 == b3-c3):
print('No')
else:
print('Yes')
| 16 | 10 | 443 | 308 |
c1 = list(map(int, input().split()))
c2 = list(map(int, input().split()))
c3 = list(map(int, input().split()))
if not c1[0] - c1[1] == c2[0] - c2[1] == c3[0] - c3[1]:
print("No")
exit()
if not c1[2] - c1[1] == c2[2] - c2[1] == c3[2] - c3[1]:
print("No")
exit()
if not c1[0] - c2[0] == c1[1] - c2[1] == c1[2] - c2[2]:
print("No")
exit()
if not c3[0] - c2[0] == c3[1] - c2[1] == c3[2] - c2[2]:
print("No")
exit()
print("Yes")
|
a1, a2, a3 = list(map(int, input().split()))
b1, b2, b3 = list(map(int, input().split()))
c1, c2, c3 = list(map(int, input().split()))
if not (a1 - a2 == b1 - b2 == c1 - c2) or not (a2 - a3 == b2 - b3 == c2 - c3):
print("No")
elif not (a1 - b1 == a2 - b2 == a3 - b3) or not (b1 - c1 == b2 - c2 == b3 - c3):
print("No")
else:
print("Yes")
| false | 37.5 |
[
"-c1 = list(map(int, input().split()))",
"-c2 = list(map(int, input().split()))",
"-c3 = list(map(int, input().split()))",
"-if not c1[0] - c1[1] == c2[0] - c2[1] == c3[0] - c3[1]:",
"+a1, a2, a3 = list(map(int, input().split()))",
"+b1, b2, b3 = list(map(int, input().split()))",
"+c1, c2, c3 = list(map(int, input().split()))",
"+if not (a1 - a2 == b1 - b2 == c1 - c2) or not (a2 - a3 == b2 - b3 == c2 - c3):",
"- exit()",
"-if not c1[2] - c1[1] == c2[2] - c2[1] == c3[2] - c3[1]:",
"+elif not (a1 - b1 == a2 - b2 == a3 - b3) or not (b1 - c1 == b2 - c2 == b3 - c3):",
"- exit()",
"-if not c1[0] - c2[0] == c1[1] - c2[1] == c1[2] - c2[2]:",
"- print(\"No\")",
"- exit()",
"-if not c3[0] - c2[0] == c3[1] - c2[1] == c3[2] - c2[2]:",
"- print(\"No\")",
"- exit()",
"-print(\"Yes\")",
"+else:",
"+ print(\"Yes\")"
] | false | 0.042829 | 0.044782 | 0.956379 |
[
"s071004201",
"s281158821"
] |
u054514819
|
p02721
|
python
|
s003266963
|
s234800928
| 286 | 133 | 102,412 | 102,108 |
Accepted
|
Accepted
| 53.5 |
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return list(map(int, input().split()))
sys.setrecursionlimit(10**9)
N, K, C = mapint()
S = list(eval(input()))
r_S = S[::-1]
pos = [0]*N
neg = [0]*N
ok = 0
cnt = 0
for i in range(N):
if S[i]=='o':
if ok<=i:
pos[i] = cnt + 1
cnt += 1
ok = i + C + 1
if cnt==K:
break
else:
pass
ok = 0
cnt = 0
for i in range(N):
if r_S[i]=='o':
if ok<=i:
neg[i] = cnt + 1
cnt += 1
ok = i + C + 1
if cnt==K:
break
else:
pass
ans = []
neg = neg[::-1]
for i in range(N):
if pos[i]+neg[i]-1==K:
ans.append(i)
for a in ans:
print((a+1))
|
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return list(map(int, input().split()))
sys.setrecursionlimit(10**9)
N, K, C = mapint()
S = list(eval(input()))
r_S = S[::-1]
pos = [10**18]*N
neg = [10**18]*N
ok = 0
cnt = 0
for i in range(N):
if S[i]=='o':
if ok<=i:
pos[i] = cnt + 1
cnt += 1
ok = i + C + 1
else:
pass
ok = 0
cnt = 0
for i in range(N):
if r_S[i]=='o':
if ok<=i:
neg[i] = cnt + 1
cnt += 1
ok = i + C + 1
else:
pass
ans = []
neg = neg[::-1]
for i in range(N):
if pos[i]+neg[i]-1==K:
ans.append(i)
for a in ans:
print((a+1))
| 46 | 42 | 815 | 731 |
import sys
def input():
return sys.stdin.readline().strip()
def mapint():
return list(map(int, input().split()))
sys.setrecursionlimit(10**9)
N, K, C = mapint()
S = list(eval(input()))
r_S = S[::-1]
pos = [0] * N
neg = [0] * N
ok = 0
cnt = 0
for i in range(N):
if S[i] == "o":
if ok <= i:
pos[i] = cnt + 1
cnt += 1
ok = i + C + 1
if cnt == K:
break
else:
pass
ok = 0
cnt = 0
for i in range(N):
if r_S[i] == "o":
if ok <= i:
neg[i] = cnt + 1
cnt += 1
ok = i + C + 1
if cnt == K:
break
else:
pass
ans = []
neg = neg[::-1]
for i in range(N):
if pos[i] + neg[i] - 1 == K:
ans.append(i)
for a in ans:
print((a + 1))
|
import sys
def input():
return sys.stdin.readline().strip()
def mapint():
return list(map(int, input().split()))
sys.setrecursionlimit(10**9)
N, K, C = mapint()
S = list(eval(input()))
r_S = S[::-1]
pos = [10**18] * N
neg = [10**18] * N
ok = 0
cnt = 0
for i in range(N):
if S[i] == "o":
if ok <= i:
pos[i] = cnt + 1
cnt += 1
ok = i + C + 1
else:
pass
ok = 0
cnt = 0
for i in range(N):
if r_S[i] == "o":
if ok <= i:
neg[i] = cnt + 1
cnt += 1
ok = i + C + 1
else:
pass
ans = []
neg = neg[::-1]
for i in range(N):
if pos[i] + neg[i] - 1 == K:
ans.append(i)
for a in ans:
print((a + 1))
| false | 8.695652 |
[
"-pos = [0] * N",
"-neg = [0] * N",
"+pos = [10**18] * N",
"+neg = [10**18] * N",
"- if cnt == K:",
"- break",
"- if cnt == K:",
"- break"
] | false | 0.03663 | 0.036724 | 0.997444 |
[
"s003266963",
"s234800928"
] |
u896741788
|
p03775
|
python
|
s210519634
|
s800426202
| 33 | 29 | 3,064 | 2,940 |
Accepted
|
Accepted
| 12.12 |
n=int(eval(input()))
a=0
l=[]
for i in range(int(n**(1/2))+1)[:0:-1]:
if n%i==0:
a+=1
l.append(max(len(str(i)),len(str(n//i))))
if a==3:break
print((min(l)))
|
from math import sqrt
n=int(eval(input()))
for i in range(int(sqrt(n)),0,-1):
if n%i==0:
print((max(len(str(i)),len(str(n//i)))))
exit()
| 9 | 6 | 169 | 144 |
n = int(eval(input()))
a = 0
l = []
for i in range(int(n ** (1 / 2)) + 1)[:0:-1]:
if n % i == 0:
a += 1
l.append(max(len(str(i)), len(str(n // i))))
if a == 3:
break
print((min(l)))
|
from math import sqrt
n = int(eval(input()))
for i in range(int(sqrt(n)), 0, -1):
if n % i == 0:
print((max(len(str(i)), len(str(n // i)))))
exit()
| false | 33.333333 |
[
"+from math import sqrt",
"+",
"-a = 0",
"-l = []",
"-for i in range(int(n ** (1 / 2)) + 1)[:0:-1]:",
"+for i in range(int(sqrt(n)), 0, -1):",
"- a += 1",
"- l.append(max(len(str(i)), len(str(n // i))))",
"- if a == 3:",
"- break",
"-print((min(l)))",
"+ print((max(len(str(i)), len(str(n // i)))))",
"+ exit()"
] | false | 0.044691 | 0.050462 | 0.885633 |
[
"s210519634",
"s800426202"
] |
u217574754
|
p03479
|
python
|
s016079928
|
s957082279
| 20 | 18 | 3,060 | 2,940 |
Accepted
|
Accepted
| 10 |
# coding: utf-8
# input
x, y = list(map(int, input().split()))
# main
count = 0
while x <= y:
count += 1
x *= 2
print(count)
|
# input
x, y = list(map(int, input().split()))
# main
c = 0
while x <= y:
x *= 2
c += 1
print(c)
| 12 | 10 | 140 | 109 |
# coding: utf-8
# input
x, y = list(map(int, input().split()))
# main
count = 0
while x <= y:
count += 1
x *= 2
print(count)
|
# input
x, y = list(map(int, input().split()))
# main
c = 0
while x <= y:
x *= 2
c += 1
print(c)
| false | 16.666667 |
[
"-# coding: utf-8",
"-count = 0",
"+c = 0",
"- count += 1",
"-print(count)",
"+ c += 1",
"+print(c)"
] | false | 0.048547 | 0.047343 | 1.025423 |
[
"s016079928",
"s957082279"
] |
u157232135
|
p02570
|
python
|
s093754693
|
s275124304
| 64 | 26 | 61,584 | 9,160 |
Accepted
|
Accepted
| 59.38 |
d,t,s=list(map(int,input().split()))
print(("Yes" if d/s<=t else "No"))
|
def main():
d,t,s=list(map(int,input().split()))
print(("Yes" if d/s<=t else "No"))
if __name__ == "__main__":
main()
| 2 | 6 | 64 | 131 |
d, t, s = list(map(int, input().split()))
print(("Yes" if d / s <= t else "No"))
|
def main():
d, t, s = list(map(int, input().split()))
print(("Yes" if d / s <= t else "No"))
if __name__ == "__main__":
main()
| false | 66.666667 |
[
"-d, t, s = list(map(int, input().split()))",
"-print((\"Yes\" if d / s <= t else \"No\"))",
"+def main():",
"+ d, t, s = list(map(int, input().split()))",
"+ print((\"Yes\" if d / s <= t else \"No\"))",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false | 0.044516 | 0.041321 | 1.07733 |
[
"s093754693",
"s275124304"
] |
u340781749
|
p02666
|
python
|
s651015536
|
s016761901
| 1,488 | 394 | 178,788 | 27,688 |
Accepted
|
Accepted
| 73.52 |
class UnionFind:
def __init__(self, n):
self.table = [-1] * n
def _root(self, x):
stack = []
tbl = self.table
while tbl[x] >= 0:
stack.append(x)
x = tbl[x]
for y in stack:
tbl[y] = x
return x
def find(self, x, y):
return self._root(x) == self._root(y)
def unite(self, x, y):
r1 = self._root(x)
r2 = self._root(y)
if r1 == r2:
return
d1 = self.table[r1]
d2 = self.table[r2]
if d1 <= d2:
self.table[r2] = r1
self.table[r1] += d2
else:
self.table[r1] = r2
self.table[r2] += d1
def get_size(self, x):
return -self.table[self._root(x)]
n = int(eval(input()))
ppp = list(map(int, input().split()))
MOD = 10 ** 9 + 7
uft = UnionFind(n)
base = 0
undefined = []
for i, p in enumerate(ppp):
if p == -1:
undefined.append(i)
continue
p -= 1
if not uft.find(i, p):
base += 1
uft.unite(i, p)
if len(undefined) == 0:
print((base % MOD))
exit()
elif len(undefined) == 1:
c = uft.get_size(undefined[0])
others = n - c
print(((base * (n - 1) + others) % MOD))
exit()
m = len(undefined)
dp = [0] * (m + 1) # 閉路のパターン数
dp[0] = 1
additional = 0 # 閉路を考慮せずに追加される辺数
for i in undefined:
c = uft.get_size(i)
for j in range(m - 1, -1, -1):
dp[j + 1] += dp[j] * c
additional += n - c
duplicated = 0
pat = pow(n - 1, m, MOD)
inv = pow(n - 1, MOD - 2, MOD)
loop_permutation = 1
loop_other_pattern = pat * inv * inv % MOD
for loop_size in range(2, m + 1):
duplicated = (duplicated + dp[loop_size] * loop_permutation * loop_other_pattern) % MOD
loop_other_pattern = loop_other_pattern * inv % MOD
loop_permutation = loop_permutation * loop_size % MOD
ans = (base * pat + additional * pat * inv - duplicated) % MOD
print(ans)
|
import numpy as np
class UnionFind:
def __init__(self, n):
self.table = [-1] * n
def _root(self, x):
stack = []
tbl = self.table
while tbl[x] >= 0:
stack.append(x)
x = tbl[x]
for y in stack:
tbl[y] = x
return x
def find(self, x, y):
return self._root(x) == self._root(y)
def unite(self, x, y):
r1 = self._root(x)
r2 = self._root(y)
if r1 == r2:
return
d1 = self.table[r1]
d2 = self.table[r2]
if d1 <= d2:
self.table[r2] = r1
self.table[r1] += d2
else:
self.table[r1] = r2
self.table[r2] += d1
def get_size(self, x):
return -self.table[self._root(x)]
n = int(eval(input()))
ppp = list(map(int, input().split()))
MOD = 10 ** 9 + 7
uft = UnionFind(n)
base = 0
undefined = []
for i, p in enumerate(ppp):
if p == -1:
undefined.append(i)
continue
p -= 1
if not uft.find(i, p):
base += 1
uft.unite(i, p)
if len(undefined) == 0:
print((base % MOD))
exit()
elif len(undefined) == 1:
c = uft.get_size(undefined[0])
others = n - c
print(((base * (n - 1) + others) % MOD))
exit()
m = len(undefined)
dp = np.zeros(m + 1, dtype=np.int64) # 閉路のパターン数
dp[0] = 1
additional = 0 # 閉路を考慮せずに追加される辺数
for i in undefined:
c = uft.get_size(i)
dp[1:] += dp[:-1] * c
dp %= MOD
additional += n - c
dp = dp.tolist()
duplicated = 0
pat = pow(n - 1, m, MOD)
inv = pow(n - 1, MOD - 2, MOD)
loop_permutation = 1
loop_other_pattern = pat * inv * inv % MOD
for loop_size in range(2, m + 1):
duplicated = (duplicated + dp[loop_size] * loop_permutation * loop_other_pattern) % MOD
loop_other_pattern = loop_other_pattern * inv % MOD
loop_permutation = loop_permutation * loop_size % MOD
ans = (base * pat + additional * pat * inv - duplicated) % MOD
print(ans)
| 83 | 87 | 2,014 | 2,048 |
class UnionFind:
def __init__(self, n):
self.table = [-1] * n
def _root(self, x):
stack = []
tbl = self.table
while tbl[x] >= 0:
stack.append(x)
x = tbl[x]
for y in stack:
tbl[y] = x
return x
def find(self, x, y):
return self._root(x) == self._root(y)
def unite(self, x, y):
r1 = self._root(x)
r2 = self._root(y)
if r1 == r2:
return
d1 = self.table[r1]
d2 = self.table[r2]
if d1 <= d2:
self.table[r2] = r1
self.table[r1] += d2
else:
self.table[r1] = r2
self.table[r2] += d1
def get_size(self, x):
return -self.table[self._root(x)]
n = int(eval(input()))
ppp = list(map(int, input().split()))
MOD = 10**9 + 7
uft = UnionFind(n)
base = 0
undefined = []
for i, p in enumerate(ppp):
if p == -1:
undefined.append(i)
continue
p -= 1
if not uft.find(i, p):
base += 1
uft.unite(i, p)
if len(undefined) == 0:
print((base % MOD))
exit()
elif len(undefined) == 1:
c = uft.get_size(undefined[0])
others = n - c
print(((base * (n - 1) + others) % MOD))
exit()
m = len(undefined)
dp = [0] * (m + 1) # 閉路のパターン数
dp[0] = 1
additional = 0 # 閉路を考慮せずに追加される辺数
for i in undefined:
c = uft.get_size(i)
for j in range(m - 1, -1, -1):
dp[j + 1] += dp[j] * c
additional += n - c
duplicated = 0
pat = pow(n - 1, m, MOD)
inv = pow(n - 1, MOD - 2, MOD)
loop_permutation = 1
loop_other_pattern = pat * inv * inv % MOD
for loop_size in range(2, m + 1):
duplicated = (
duplicated + dp[loop_size] * loop_permutation * loop_other_pattern
) % MOD
loop_other_pattern = loop_other_pattern * inv % MOD
loop_permutation = loop_permutation * loop_size % MOD
ans = (base * pat + additional * pat * inv - duplicated) % MOD
print(ans)
|
import numpy as np
class UnionFind:
def __init__(self, n):
self.table = [-1] * n
def _root(self, x):
stack = []
tbl = self.table
while tbl[x] >= 0:
stack.append(x)
x = tbl[x]
for y in stack:
tbl[y] = x
return x
def find(self, x, y):
return self._root(x) == self._root(y)
def unite(self, x, y):
r1 = self._root(x)
r2 = self._root(y)
if r1 == r2:
return
d1 = self.table[r1]
d2 = self.table[r2]
if d1 <= d2:
self.table[r2] = r1
self.table[r1] += d2
else:
self.table[r1] = r2
self.table[r2] += d1
def get_size(self, x):
return -self.table[self._root(x)]
n = int(eval(input()))
ppp = list(map(int, input().split()))
MOD = 10**9 + 7
uft = UnionFind(n)
base = 0
undefined = []
for i, p in enumerate(ppp):
if p == -1:
undefined.append(i)
continue
p -= 1
if not uft.find(i, p):
base += 1
uft.unite(i, p)
if len(undefined) == 0:
print((base % MOD))
exit()
elif len(undefined) == 1:
c = uft.get_size(undefined[0])
others = n - c
print(((base * (n - 1) + others) % MOD))
exit()
m = len(undefined)
dp = np.zeros(m + 1, dtype=np.int64) # 閉路のパターン数
dp[0] = 1
additional = 0 # 閉路を考慮せずに追加される辺数
for i in undefined:
c = uft.get_size(i)
dp[1:] += dp[:-1] * c
dp %= MOD
additional += n - c
dp = dp.tolist()
duplicated = 0
pat = pow(n - 1, m, MOD)
inv = pow(n - 1, MOD - 2, MOD)
loop_permutation = 1
loop_other_pattern = pat * inv * inv % MOD
for loop_size in range(2, m + 1):
duplicated = (
duplicated + dp[loop_size] * loop_permutation * loop_other_pattern
) % MOD
loop_other_pattern = loop_other_pattern * inv % MOD
loop_permutation = loop_permutation * loop_size % MOD
ans = (base * pat + additional * pat * inv - duplicated) % MOD
print(ans)
| false | 4.597701 |
[
"+import numpy as np",
"+",
"+",
"-dp = [0] * (m + 1) # 閉路のパターン数",
"+dp = np.zeros(m + 1, dtype=np.int64) # 閉路のパターン数",
"- for j in range(m - 1, -1, -1):",
"- dp[j + 1] += dp[j] * c",
"+ dp[1:] += dp[:-1] * c",
"+ dp %= MOD",
"+dp = dp.tolist()"
] | false | 0.11624 | 0.34494 | 0.336985 |
[
"s651015536",
"s016761901"
] |
u707498674
|
p03583
|
python
|
s315409546
|
s928732779
| 1,054 | 261 | 3,060 | 3,060 |
Accepted
|
Accepted
| 75.24 |
def main():
N = int(eval(input()))
for h in range(1, 3501):
for n in range(h, 3501):
if (4*h*n - N*h - N*n)>0 and N*h*n % (4*h*n - N*h - N*n)==0:
w = N*h*n // (4*h*n - N*h - N*n)
print((h, n, w))
exit()
if __name__ == "__main__":
main()
|
def main():
N = int(eval(input()))
for h in range(1, 3501):
for n in range(max(h, N-h+1), 3501):
if (4*h*n - N*h - N*n)>0 and N*h*n % (4*h*n - N*h - N*n)==0:
w = N*h*n // (4*h*n - N*h - N*n)
print((h, n, w))
exit()
if __name__ == "__main__":
main()
| 12 | 12 | 321 | 333 |
def main():
N = int(eval(input()))
for h in range(1, 3501):
for n in range(h, 3501):
if (4 * h * n - N * h - N * n) > 0 and N * h * n % (
4 * h * n - N * h - N * n
) == 0:
w = N * h * n // (4 * h * n - N * h - N * n)
print((h, n, w))
exit()
if __name__ == "__main__":
main()
|
def main():
N = int(eval(input()))
for h in range(1, 3501):
for n in range(max(h, N - h + 1), 3501):
if (4 * h * n - N * h - N * n) > 0 and N * h * n % (
4 * h * n - N * h - N * n
) == 0:
w = N * h * n // (4 * h * n - N * h - N * n)
print((h, n, w))
exit()
if __name__ == "__main__":
main()
| false | 0 |
[
"- for n in range(h, 3501):",
"+ for n in range(max(h, N - h + 1), 3501):"
] | false | 0.007928 | 0.301112 | 0.026328 |
[
"s315409546",
"s928732779"
] |
u952708174
|
p03599
|
python
|
s893072109
|
s692502453
| 68 | 48 | 3,188 | 3,188 |
Accepted
|
Accepted
| 29.41 |
def c_sugar_water(A, B, C, D, E, F):
x = set() # 水の量が取りうるパターン
y = set() # 砂糖の量が取りうるパターン
for i in range(F // 100 + 1):
for j in range(F // 100 + 1):
tmp = 100 * A * i + 100 * B * j
if tmp <= F:
x.add(tmp)
else:
break # A, Bは正整数なので、Fを超えるようなjの値にする意味がない
for i in range(F):
for j in range(F):
tmp = C * i + D * j
if tmp <= F:
y.add(tmp)
else:
break
concentration = 0 # 砂糖水の濃度
tmp = [0, 0]
for water in x:
for sugar in y:
if water == 0 and sugar == 0:
continue # 水も砂糖も入れていない
elif E * (water // 100) < sugar:
continue # 砂糖を溶かしきれない
elif water + sugar > F:
continue # ビーカーに入れられる質量を超えた
else:
if (100 * sugar) / (water + sugar) >= concentration:
concentration = (100 * sugar) / (water + sugar)
tmp = [water + sugar, sugar]
ans = '{} {}'.format(tmp[0], tmp[1])
return ans
A, B, C, D, E, F = [int(i) for i in input().split()]
print((c_sugar_water(A, B, C, D, E, F)))
|
def c_sugar_water(A, B, C, D, E, F):
x = set() # 水の量が取りうるパターン
y = set() # 砂糖の量が取りうるパターン
for a in range(0, F + 1, 100 * A):
for b in range(0, F - a + 1, 100 * B):
x.add(a + b)
for c in range(0, F + 1, C):
for d in range(0, F - c + 1, D):
y.add(c + d)
concentration = -1.0 # 砂糖水の濃度
tmp = [0, 0]
for water in x:
for sugar in y:
# 砂糖水の質量がビーカーに入れられるもので、砂糖が溶け残らない
if 0 < water + sugar <= F and E * (water // 100) >= sugar:
if concentration < sugar / (water + sugar):
tmp = (water + sugar, sugar)
concentration = sugar / (water + sugar)
ans = '{} {}'.format(*tmp)
return ans
A, B, C, D, E, F = [int(i) for i in input().split()]
print((c_sugar_water(A, B, C, D, E, F)))
| 37 | 24 | 1,244 | 851 |
def c_sugar_water(A, B, C, D, E, F):
x = set() # 水の量が取りうるパターン
y = set() # 砂糖の量が取りうるパターン
for i in range(F // 100 + 1):
for j in range(F // 100 + 1):
tmp = 100 * A * i + 100 * B * j
if tmp <= F:
x.add(tmp)
else:
break # A, Bは正整数なので、Fを超えるようなjの値にする意味がない
for i in range(F):
for j in range(F):
tmp = C * i + D * j
if tmp <= F:
y.add(tmp)
else:
break
concentration = 0 # 砂糖水の濃度
tmp = [0, 0]
for water in x:
for sugar in y:
if water == 0 and sugar == 0:
continue # 水も砂糖も入れていない
elif E * (water // 100) < sugar:
continue # 砂糖を溶かしきれない
elif water + sugar > F:
continue # ビーカーに入れられる質量を超えた
else:
if (100 * sugar) / (water + sugar) >= concentration:
concentration = (100 * sugar) / (water + sugar)
tmp = [water + sugar, sugar]
ans = "{} {}".format(tmp[0], tmp[1])
return ans
A, B, C, D, E, F = [int(i) for i in input().split()]
print((c_sugar_water(A, B, C, D, E, F)))
|
def c_sugar_water(A, B, C, D, E, F):
x = set() # 水の量が取りうるパターン
y = set() # 砂糖の量が取りうるパターン
for a in range(0, F + 1, 100 * A):
for b in range(0, F - a + 1, 100 * B):
x.add(a + b)
for c in range(0, F + 1, C):
for d in range(0, F - c + 1, D):
y.add(c + d)
concentration = -1.0 # 砂糖水の濃度
tmp = [0, 0]
for water in x:
for sugar in y:
# 砂糖水の質量がビーカーに入れられるもので、砂糖が溶け残らない
if 0 < water + sugar <= F and E * (water // 100) >= sugar:
if concentration < sugar / (water + sugar):
tmp = (water + sugar, sugar)
concentration = sugar / (water + sugar)
ans = "{} {}".format(*tmp)
return ans
A, B, C, D, E, F = [int(i) for i in input().split()]
print((c_sugar_water(A, B, C, D, E, F)))
| false | 35.135135 |
[
"- for i in range(F // 100 + 1):",
"- for j in range(F // 100 + 1):",
"- tmp = 100 * A * i + 100 * B * j",
"- if tmp <= F:",
"- x.add(tmp)",
"- else:",
"- break # A, Bは正整数なので、Fを超えるようなjの値にする意味がない",
"- for i in range(F):",
"- for j in range(F):",
"- tmp = C * i + D * j",
"- if tmp <= F:",
"- y.add(tmp)",
"- else:",
"- break",
"- concentration = 0 # 砂糖水の濃度",
"+ for a in range(0, F + 1, 100 * A):",
"+ for b in range(0, F - a + 1, 100 * B):",
"+ x.add(a + b)",
"+ for c in range(0, F + 1, C):",
"+ for d in range(0, F - c + 1, D):",
"+ y.add(c + d)",
"+ concentration = -1.0 # 砂糖水の濃度",
"- if water == 0 and sugar == 0:",
"- continue # 水も砂糖も入れていない",
"- elif E * (water // 100) < sugar:",
"- continue # 砂糖を溶かしきれない",
"- elif water + sugar > F:",
"- continue # ビーカーに入れられる質量を超えた",
"- else:",
"- if (100 * sugar) / (water + sugar) >= concentration:",
"- concentration = (100 * sugar) / (water + sugar)",
"- tmp = [water + sugar, sugar]",
"- ans = \"{} {}\".format(tmp[0], tmp[1])",
"+ # 砂糖水の質量がビーカーに入れられるもので、砂糖が溶け残らない",
"+ if 0 < water + sugar <= F and E * (water // 100) >= sugar:",
"+ if concentration < sugar / (water + sugar):",
"+ tmp = (water + sugar, sugar)",
"+ concentration = sugar / (water + sugar)",
"+ ans = \"{} {}\".format(*tmp)"
] | false | 0.045687 | 0.053085 | 0.860637 |
[
"s893072109",
"s692502453"
] |
u997521090
|
p03209
|
python
|
s448286319
|
s136850056
| 12 | 10 | 2,692 | 2,568 |
Accepted
|
Accepted
| 16.67 |
def f(v,i):s,n=4*2**v-3,2*2**v-1;m=s/2+1;return 0 if i<1 or i>s else[0,f(v-1,i-1),n/2+1,f(v-1,i-m)+n/2+1,n,1][(i>1)+(i>=m)+(i>m)+(i>=s)+(v==0)*3]
print(f(*list(map(int,input().split()))))
|
def f(v,i):s,n=4*2**v-3,2*2**v-1;m=s/2+1;return 0 if(i<1)+(i>s)else[0,f(v-1,i-1),n/2+1,f(v-1,i-m)+n/2+1,n,1][(i>1)+(i>=m)+(i>m)+(i>=s)+(v==0)*3]
print(f(*list(map(int,input().split()))))
| 2 | 2 | 185 | 184 |
def f(v, i):
s, n = 4 * 2**v - 3, 2 * 2**v - 1
m = s / 2 + 1
return (
0
if i < 1 or i > s
else [0, f(v - 1, i - 1), n / 2 + 1, f(v - 1, i - m) + n / 2 + 1, n, 1][
(i > 1) + (i >= m) + (i > m) + (i >= s) + (v == 0) * 3
]
)
print(f(*list(map(int, input().split()))))
|
def f(v, i):
s, n = 4 * 2**v - 3, 2 * 2**v - 1
m = s / 2 + 1
return (
0
if (i < 1) + (i > s)
else [0, f(v - 1, i - 1), n / 2 + 1, f(v - 1, i - m) + n / 2 + 1, n, 1][
(i > 1) + (i >= m) + (i > m) + (i >= s) + (v == 0) * 3
]
)
print(f(*list(map(int, input().split()))))
| false | 0 |
[
"- if i < 1 or i > s",
"+ if (i < 1) + (i > s)"
] | false | 0.048861 | 0.223019 | 0.219089 |
[
"s448286319",
"s136850056"
] |
u631277801
|
p03965
|
python
|
s824302925
|
s450597421
| 19 | 17 | 3,188 | 3,188 |
Accepted
|
Accepted
| 10.53 |
s = eval(input())
g_num = s.count("g")
print((g_num - (len(s)+1)//2))
|
s = eval(input())
print((len(s)//2 - s.count("p")))
| 4 | 2 | 65 | 44 |
s = eval(input())
g_num = s.count("g")
print((g_num - (len(s) + 1) // 2))
|
s = eval(input())
print((len(s) // 2 - s.count("p")))
| false | 50 |
[
"-g_num = s.count(\"g\")",
"-print((g_num - (len(s) + 1) // 2))",
"+print((len(s) // 2 - s.count(\"p\")))"
] | false | 0.069505 | 0.050101 | 1.387307 |
[
"s824302925",
"s450597421"
] |
u425177436
|
p03033
|
python
|
s794593350
|
s077849168
| 1,683 | 1,044 | 57,056 | 57,056 |
Accepted
|
Accepted
| 37.97 |
from bisect import bisect_left
N, Q = map(int, input().split())
W = [tuple(map(int, input().split())) for _ in range(N)]
W.sort(key=lambda x:x[2])
D = [int(input()) for _ in range(Q)]
ans = [-1]*Q
skip = [-1]*Q
for s, t, x in W:
l = bisect_left(D, s-x)
r = bisect_left(D, t-x)
while l < r:
if skip[l] == -1:
ans[l] = x
skip[l] = r
l += 1
else:
l = skip[l]
print(*ans, sep='\n')
|
import sys
input = sys.stdin.readline
from bisect import bisect_left
N, Q = map(int, input().split())
W = [tuple(map(int, input().split())) for _ in range(N)]
W.sort(key=lambda x:x[2])
D = [int(input()) for _ in range(Q)]
ans = [-1]*Q
skip = [-1]*Q
for s, t, x in W:
l = bisect_left(D, s-x)
r = bisect_left(D, t-x)
while l < r:
if skip[l] == -1:
ans[l] = x
skip[l] = r
l += 1
else:
l = skip[l]
print(*ans, sep='\n')
| 18 | 20 | 470 | 510 |
from bisect import bisect_left
N, Q = map(int, input().split())
W = [tuple(map(int, input().split())) for _ in range(N)]
W.sort(key=lambda x: x[2])
D = [int(input()) for _ in range(Q)]
ans = [-1] * Q
skip = [-1] * Q
for s, t, x in W:
l = bisect_left(D, s - x)
r = bisect_left(D, t - x)
while l < r:
if skip[l] == -1:
ans[l] = x
skip[l] = r
l += 1
else:
l = skip[l]
print(*ans, sep="\n")
|
import sys
input = sys.stdin.readline
from bisect import bisect_left
N, Q = map(int, input().split())
W = [tuple(map(int, input().split())) for _ in range(N)]
W.sort(key=lambda x: x[2])
D = [int(input()) for _ in range(Q)]
ans = [-1] * Q
skip = [-1] * Q
for s, t, x in W:
l = bisect_left(D, s - x)
r = bisect_left(D, t - x)
while l < r:
if skip[l] == -1:
ans[l] = x
skip[l] = r
l += 1
else:
l = skip[l]
print(*ans, sep="\n")
| false | 10 |
[
"+import sys",
"+",
"+input = sys.stdin.readline"
] | false | 0.038011 | 0.037881 | 1.003407 |
[
"s794593350",
"s077849168"
] |
u349449706
|
p02954
|
python
|
s005570027
|
s263992350
| 101 | 88 | 78,988 | 78,896 |
Accepted
|
Accepted
| 12.87 |
S = eval(input())
n = len(S)
A = [0] * n
p = 0
for i in range(n-1):
if S[i] == 'R' and S[i+1] == 'L':
for j in range(p, i+1):
if S[j] == 'R':
if (i+1-j)%2==0:
A[i+1]+=1
else:
A[i]+=1
p = i + 1
p = n - 1
for i in range(n-1, 0, -1):
if S[i-1] == 'R' and S[i] == 'L':
for j in range(p, i-1, -1):
if S[j] == 'L':
if (i-1-j)%2==0:
A[i-1]+=1
else:
A[i]+=1
p = i - 1
print((*A))
|
S=eval(input())+'R'
n=len(S)-1
a=[0]*n
r=0
while r<n:
l=S.find('L',r)
a[l]+=(l-r)//2
a[l-1]+=(l-r+1)//2
r=S.find('R',l)
a[l]+=(r-l+1)//2
a[l-1]+=(r-l)//2
print((*a))
| 24 | 12 | 595 | 193 |
S = eval(input())
n = len(S)
A = [0] * n
p = 0
for i in range(n - 1):
if S[i] == "R" and S[i + 1] == "L":
for j in range(p, i + 1):
if S[j] == "R":
if (i + 1 - j) % 2 == 0:
A[i + 1] += 1
else:
A[i] += 1
p = i + 1
p = n - 1
for i in range(n - 1, 0, -1):
if S[i - 1] == "R" and S[i] == "L":
for j in range(p, i - 1, -1):
if S[j] == "L":
if (i - 1 - j) % 2 == 0:
A[i - 1] += 1
else:
A[i] += 1
p = i - 1
print((*A))
|
S = eval(input()) + "R"
n = len(S) - 1
a = [0] * n
r = 0
while r < n:
l = S.find("L", r)
a[l] += (l - r) // 2
a[l - 1] += (l - r + 1) // 2
r = S.find("R", l)
a[l] += (r - l + 1) // 2
a[l - 1] += (r - l) // 2
print((*a))
| false | 50 |
[
"-S = eval(input())",
"-n = len(S)",
"-A = [0] * n",
"-p = 0",
"-for i in range(n - 1):",
"- if S[i] == \"R\" and S[i + 1] == \"L\":",
"- for j in range(p, i + 1):",
"- if S[j] == \"R\":",
"- if (i + 1 - j) % 2 == 0:",
"- A[i + 1] += 1",
"- else:",
"- A[i] += 1",
"- p = i + 1",
"-p = n - 1",
"-for i in range(n - 1, 0, -1):",
"- if S[i - 1] == \"R\" and S[i] == \"L\":",
"- for j in range(p, i - 1, -1):",
"- if S[j] == \"L\":",
"- if (i - 1 - j) % 2 == 0:",
"- A[i - 1] += 1",
"- else:",
"- A[i] += 1",
"- p = i - 1",
"-print((*A))",
"+S = eval(input()) + \"R\"",
"+n = len(S) - 1",
"+a = [0] * n",
"+r = 0",
"+while r < n:",
"+ l = S.find(\"L\", r)",
"+ a[l] += (l - r) // 2",
"+ a[l - 1] += (l - r + 1) // 2",
"+ r = S.find(\"R\", l)",
"+ a[l] += (r - l + 1) // 2",
"+ a[l - 1] += (r - l) // 2",
"+print((*a))"
] | false | 0.034411 | 0.108157 | 0.31816 |
[
"s005570027",
"s263992350"
] |
u638456847
|
p02757
|
python
|
s015762879
|
s271986955
| 488 | 135 | 13,364 | 5,504 |
Accepted
|
Accepted
| 72.34 |
from collections import Counter
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
def main():
N, P = list(map(int, readline().split()))
S = [int(i) for i in readline().strip()[::-1]]
ans = 0
if P == 2 or P == 5:
for i, s in enumerate(S):
if s % P == 0:
ans += N - i
print(ans)
exit()
a = [0]
s = 0
for i in range(N):
s += S[i] * pow(10, i, P)
a.append(s % P)
t = Counter(a)
ans = 0
for v in list(t.values()):
ans += v * (v-1) // 2
print(ans)
if __name__ == "__main__":
main()
|
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
def main():
N, P = list(map(int, readline().split()))
S = [int(i) for i in readline().strip()[::-1]]
ans = 0
if P == 2 or P == 5:
for i, s in enumerate(S):
if s % P == 0:
ans += N - i
print(ans)
exit()
a = {}
a[0] = 1
t = 0
x = 1
for s in S:
t += s * x
t %= P
if t in a:
a[t] += 1
else:
a[t] = 1
x *= 10
x %= P
ans = 0
for v in list(a.values()):
ans += v * (v-1) // 2
print(ans)
if __name__ == "__main__":
main()
| 38 | 42 | 701 | 750 |
from collections import Counter
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
def main():
N, P = list(map(int, readline().split()))
S = [int(i) for i in readline().strip()[::-1]]
ans = 0
if P == 2 or P == 5:
for i, s in enumerate(S):
if s % P == 0:
ans += N - i
print(ans)
exit()
a = [0]
s = 0
for i in range(N):
s += S[i] * pow(10, i, P)
a.append(s % P)
t = Counter(a)
ans = 0
for v in list(t.values()):
ans += v * (v - 1) // 2
print(ans)
if __name__ == "__main__":
main()
|
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
def main():
N, P = list(map(int, readline().split()))
S = [int(i) for i in readline().strip()[::-1]]
ans = 0
if P == 2 or P == 5:
for i, s in enumerate(S):
if s % P == 0:
ans += N - i
print(ans)
exit()
a = {}
a[0] = 1
t = 0
x = 1
for s in S:
t += s * x
t %= P
if t in a:
a[t] += 1
else:
a[t] = 1
x *= 10
x %= P
ans = 0
for v in list(a.values()):
ans += v * (v - 1) // 2
print(ans)
if __name__ == "__main__":
main()
| false | 9.52381 |
[
"-from collections import Counter",
"- a = [0]",
"- s = 0",
"- for i in range(N):",
"- s += S[i] * pow(10, i, P)",
"- a.append(s % P)",
"- t = Counter(a)",
"+ a = {}",
"+ a[0] = 1",
"+ t = 0",
"+ x = 1",
"+ for s in S:",
"+ t += s * x",
"+ t %= P",
"+ if t in a:",
"+ a[t] += 1",
"+ else:",
"+ a[t] = 1",
"+ x *= 10",
"+ x %= P",
"- for v in list(t.values()):",
"+ for v in list(a.values()):"
] | false | 0.065902 | 0.038163 | 1.726884 |
[
"s015762879",
"s271986955"
] |
u497418592
|
p02577
|
python
|
s275514218
|
s191163604
| 204 | 74 | 9,176 | 9,280 |
Accepted
|
Accepted
| 63.73 |
n = int(eval(input()))
print(("Yes" if n % 9 == 0 else "No"))
|
n = eval(input())
temp = 0
for i in range(len(n)):
temp += int(n[i])
print(("Yes" if temp % 9 == 0 else "No"))
| 3 | 9 | 57 | 119 |
n = int(eval(input()))
print(("Yes" if n % 9 == 0 else "No"))
|
n = eval(input())
temp = 0
for i in range(len(n)):
temp += int(n[i])
print(("Yes" if temp % 9 == 0 else "No"))
| false | 66.666667 |
[
"-n = int(eval(input()))",
"-print((\"Yes\" if n % 9 == 0 else \"No\"))",
"+n = eval(input())",
"+temp = 0",
"+for i in range(len(n)):",
"+ temp += int(n[i])",
"+print((\"Yes\" if temp % 9 == 0 else \"No\"))"
] | false | 0.036897 | 0.037353 | 0.987789 |
[
"s275514218",
"s191163604"
] |
u746419473
|
p02887
|
python
|
s185608398
|
s358023203
| 67 | 58 | 3,316 | 3,316 |
Accepted
|
Accepted
| 13.43 |
n = int(eval(input()))
s = eval(input())
current = 0
peek = 0
ans = s[peek]
for i in range(n):
if s[current] != s[peek]:
ans += s[peek]
current = peek
peek += 1
print((len(ans)))
|
n = int(eval(input()))
s = eval(input())
current = 0
ans = s[current]
for i in range(n):
if s[current] != s[i]:
ans += s[i]
current = i
print((len(ans)))
| 14 | 11 | 205 | 172 |
n = int(eval(input()))
s = eval(input())
current = 0
peek = 0
ans = s[peek]
for i in range(n):
if s[current] != s[peek]:
ans += s[peek]
current = peek
peek += 1
print((len(ans)))
|
n = int(eval(input()))
s = eval(input())
current = 0
ans = s[current]
for i in range(n):
if s[current] != s[i]:
ans += s[i]
current = i
print((len(ans)))
| false | 21.428571 |
[
"-peek = 0",
"-ans = s[peek]",
"+ans = s[current]",
"- if s[current] != s[peek]:",
"- ans += s[peek]",
"- current = peek",
"- peek += 1",
"+ if s[current] != s[i]:",
"+ ans += s[i]",
"+ current = i"
] | false | 0.042496 | 0.066773 | 0.636431 |
[
"s185608398",
"s358023203"
] |
u469254913
|
p02720
|
python
|
s499465498
|
s891092472
| 78 | 62 | 11,884 | 7,540 |
Accepted
|
Accepted
| 20.51 |
# import numpy as np
# import math
# import copy
from collections import deque
import sys
input = sys.stdin.readline
# sys.setrecursionlimit(10000)
def main():
K = int(eval(input()))
queue = deque()
for i in range(1,10):
queue.append(i)
for i in range(K):
x = queue.popleft()
d = x % 10
temp = 10 * x + d
if d != 0:
queue.append(temp - 1)
queue.append(temp)
if d != 9:
queue.append(temp + 1)
print(x)
main()
|
# import numpy as np
# import math
# import copy
from collections import deque
import sys
input = sys.stdin.readline
# sys.setrecursionlimit(10000)
def main():
K = int(eval(input()))
pre = [i for i in range(1,10)]
now = []
if K <= 10:
print(K)
sys.exit()
count = 9
for i in range(2,11):
for j in pre:
for k in range(-1,2):
d = j % 10 + k
if (d < 0) | (d > 9):
continue
temp = j * 10 + d
now.append(temp)
count += 1
if count == K:
print(temp)
sys.exit()
pre = now
main()
| 32 | 38 | 542 | 734 |
# import numpy as np
# import math
# import copy
from collections import deque
import sys
input = sys.stdin.readline
# sys.setrecursionlimit(10000)
def main():
K = int(eval(input()))
queue = deque()
for i in range(1, 10):
queue.append(i)
for i in range(K):
x = queue.popleft()
d = x % 10
temp = 10 * x + d
if d != 0:
queue.append(temp - 1)
queue.append(temp)
if d != 9:
queue.append(temp + 1)
print(x)
main()
|
# import numpy as np
# import math
# import copy
from collections import deque
import sys
input = sys.stdin.readline
# sys.setrecursionlimit(10000)
def main():
K = int(eval(input()))
pre = [i for i in range(1, 10)]
now = []
if K <= 10:
print(K)
sys.exit()
count = 9
for i in range(2, 11):
for j in pre:
for k in range(-1, 2):
d = j % 10 + k
if (d < 0) | (d > 9):
continue
temp = j * 10 + d
now.append(temp)
count += 1
if count == K:
print(temp)
sys.exit()
pre = now
main()
| false | 15.789474 |
[
"- queue = deque()",
"- for i in range(1, 10):",
"- queue.append(i)",
"- for i in range(K):",
"- x = queue.popleft()",
"- d = x % 10",
"- temp = 10 * x + d",
"- if d != 0:",
"- queue.append(temp - 1)",
"- queue.append(temp)",
"- if d != 9:",
"- queue.append(temp + 1)",
"- print(x)",
"+ pre = [i for i in range(1, 10)]",
"+ now = []",
"+ if K <= 10:",
"+ print(K)",
"+ sys.exit()",
"+ count = 9",
"+ for i in range(2, 11):",
"+ for j in pre:",
"+ for k in range(-1, 2):",
"+ d = j % 10 + k",
"+ if (d < 0) | (d > 9):",
"+ continue",
"+ temp = j * 10 + d",
"+ now.append(temp)",
"+ count += 1",
"+ if count == K:",
"+ print(temp)",
"+ sys.exit()",
"+ pre = now"
] | false | 0.043337 | 0.041886 | 1.034638 |
[
"s499465498",
"s891092472"
] |
u811733736
|
p00033
|
python
|
s547913071
|
s104997914
| 120 | 30 | 7,692 | 7,780 |
Accepted
|
Accepted
| 75 |
import sys
from itertools import compress
def is_right_order(B, C):
max_val = 0
for b in B:
if b < max_val:
return False
max_val = b
max_val = 0
for c in C:
if c < max_val:
return False
max_val = c
return True
def solve_bf(d):
""" ??????????????§?§£??? """
for i in range(1024):
bin_i = '{0:010b}'.format(i)
bin_i = [int(x) for x in bin_i]
comp = compress(d, bin_i)
B = list(comp)
C = d[:]
for b in B:
C.remove(b)
if is_right_order(B, C):
return True
return False
if __name__ == '__main__':
# ??????????????\???
num = int(eval(input()))
data = []
for _ in range(num):
data.append(list(map(int, input().split(' '))))
# ????????????
for d in data:
result = solve_bf(d)
# ???????????¨???
if result:
print('YES')
else:
print('NO')
|
# import sys
from itertools import compress
# from random import shuffle, seed, random
from time import perf_counter
def is_right_order(B, C):
""" B, C????????§??????????????????????????????(??????)????????§???????????? """
max_val = 0
for b in B:
if b < max_val:
return False
max_val = b
max_val = 0
for c in C:
if c < max_val:
return False
max_val = c
return True
def solve_bf(d):
""" ??????????????§?§£???(??????) """
for i in range(1024): # ????????§??????????????????????????????????????????????????????B?????????C????????????????????????
bin_i = '{0:010b}'.format(i)
bin_i = [int(x) for x in bin_i]
comp = compress(d, bin_i)
B = list(comp)
C = d[:]
for b in B:
C.remove(b)
if is_right_order(B, C): # ???????????????????????????????????§?????¶???????????????????????????????¨???????
return True
return False
def solve_greed(d):
""" ????¬????????????????
????????¨?????????????????????????????\????????????C?????\?????????????????\?????????B?????\?????????
??? ???????????????????????????????????°????????¨???????????????????????¨????????????????????????????????´?????????
"""
used = [False] * 11 # ???????????????????????????????????????????????°?????????????????????index??????????????????used[1]?????????????????????????????§????????????+1????????????
B = [] # ?????\????????????????????\?????????
C = [] # ????????\???????????????????????????????????\?????????
for b in d:
cb = 0
for i in range(1, 11):
if used[i] == False:
cb = i # ?????????????????????????????????????????\????????????cb??¨?????¶
break
if b == cb:
C.append(b)
else:
B.append(b)
used[b] = True # ????????????????????????????????????B?????????C???????????????????????????????????§????????¨?????????
return is_right_order(B, C)
if __name__ == '__main__':
# ??????????????\???
num = int(eval(input()))
data = []
for _ in range(num):
data.append(list(map(int, input().split(' '))))
# ???????????¨??????????????????????????????
# for i in range(100):
# t = list(range(1, 11))
# shuffle(t)
# data.append(t)
# start_time = perf_counter()
# ????????????
for d in data:
# print('trying: {0}'.format(d))
#result = solve_bf(d)
result = solve_greed(d)
if result:
print('YES')
else:
print('NO')
# end_time = perf_counter()
# print('elapsed: {0}'.format(end_time - start_time))
| 51 | 87 | 1,036 | 2,792 |
import sys
from itertools import compress
def is_right_order(B, C):
max_val = 0
for b in B:
if b < max_val:
return False
max_val = b
max_val = 0
for c in C:
if c < max_val:
return False
max_val = c
return True
def solve_bf(d):
"""??????????????§?§£???"""
for i in range(1024):
bin_i = "{0:010b}".format(i)
bin_i = [int(x) for x in bin_i]
comp = compress(d, bin_i)
B = list(comp)
C = d[:]
for b in B:
C.remove(b)
if is_right_order(B, C):
return True
return False
if __name__ == "__main__":
# ??????????????\???
num = int(eval(input()))
data = []
for _ in range(num):
data.append(list(map(int, input().split(" "))))
# ????????????
for d in data:
result = solve_bf(d)
# ???????????¨???
if result:
print("YES")
else:
print("NO")
|
# import sys
from itertools import compress
# from random import shuffle, seed, random
from time import perf_counter
def is_right_order(B, C):
"""B, C????????§??????????????????????????????(??????)????????§????????????"""
max_val = 0
for b in B:
if b < max_val:
return False
max_val = b
max_val = 0
for c in C:
if c < max_val:
return False
max_val = c
return True
def solve_bf(d):
"""??????????????§?§£???(??????)"""
for i in range(
1024
): # ????????§??????????????????????????????????????????????????????B?????????C????????????????????????
bin_i = "{0:010b}".format(i)
bin_i = [int(x) for x in bin_i]
comp = compress(d, bin_i)
B = list(comp)
C = d[:]
for b in B:
C.remove(b)
if is_right_order(
B, C
): # ???????????????????????????????????§?????¶???????????????????????????????¨???????
return True
return False
def solve_greed(d):
"""????¬????????????????
????????¨?????????????????????????????\????????????C?????\?????????????????\?????????B?????\?????????
??? ???????????????????????????????????°????????¨???????????????????????¨????????????????????????????????´?????????
"""
used = [
False
] * 11 # ???????????????????????????????????????????????°?????????????????????index??????????????????used[1]?????????????????????????????§????????????+1????????????
B = [] # ?????\????????????????????\?????????
C = [] # ????????\???????????????????????????????????\?????????
for b in d:
cb = 0
for i in range(1, 11):
if used[i] == False:
cb = i # ?????????????????????????????????????????\????????????cb??¨?????¶
break
if b == cb:
C.append(b)
else:
B.append(b)
used[
b
] = True # ????????????????????????????????????B?????????C???????????????????????????????????§????????¨?????????
return is_right_order(B, C)
if __name__ == "__main__":
# ??????????????\???
num = int(eval(input()))
data = []
for _ in range(num):
data.append(list(map(int, input().split(" "))))
# ???????????¨??????????????????????????????
# for i in range(100):
# t = list(range(1, 11))
# shuffle(t)
# data.append(t)
# start_time = perf_counter()
# ????????????
for d in data:
# print('trying: {0}'.format(d))
# result = solve_bf(d)
result = solve_greed(d)
if result:
print("YES")
else:
print("NO")
# end_time = perf_counter()
# print('elapsed: {0}'.format(end_time - start_time))
| false | 41.37931 |
[
"-import sys",
"+# import sys",
"+",
"+# from random import shuffle, seed, random",
"+from time import perf_counter",
"+ \"\"\"B, C????????§??????????????????????????????(??????)????????§????????????\"\"\"",
"- \"\"\"??????????????§?§£???\"\"\"",
"- for i in range(1024):",
"+ \"\"\"??????????????§?§£???(??????)\"\"\"",
"+ for i in range(",
"+ 1024",
"+ ): # ????????§??????????????????????????????????????????????????????B?????????C????????????????????????",
"- if is_right_order(B, C):",
"+ if is_right_order(",
"+ B, C",
"+ ): # ???????????????????????????????????§?????¶???????????????????????????????¨???????",
"+",
"+",
"+def solve_greed(d):",
"+ \"\"\"????¬????????????????",
"+ ????????¨?????????????????????????????\\????????????C?????\\?????????????????\\?????????B?????\\?????????",
"+ ??? ???????????????????????????????????°????????¨???????????????????????¨????????????????????????????????´?????????",
"+ \"\"\"",
"+ used = [",
"+ False",
"+ ] * 11 # ???????????????????????????????????????????????°?????????????????????index??????????????????used[1]?????????????????????????????§????????????+1????????????",
"+ B = [] # ?????\\????????????????????\\?????????",
"+ C = [] # ????????\\???????????????????????????????????\\?????????",
"+ for b in d:",
"+ cb = 0",
"+ for i in range(1, 11):",
"+ if used[i] == False:",
"+ cb = i # ?????????????????????????????????????????\\????????????cb??¨?????¶",
"+ break",
"+ if b == cb:",
"+ C.append(b)",
"+ else:",
"+ B.append(b)",
"+ used[",
"+ b",
"+ ] = True # ????????????????????????????????????B?????????C???????????????????????????????????§????????¨?????????",
"+ return is_right_order(B, C)",
"+ # ???????????¨??????????????????????????????",
"+ # for i in range(100):",
"+ # t = list(range(1, 11))",
"+ # shuffle(t)",
"+ # data.append(t)",
"+ # start_time = perf_counter()",
"- result = solve_bf(d)",
"- # ???????????¨???",
"+ # print('trying: {0}'.format(d))",
"+ # result = solve_bf(d)",
"+ result = solve_greed(d)",
"+ # end_time = perf_counter()",
"+ # print('elapsed: {0}'.format(end_time - start_time))"
] | false | 0.101403 | 0.044551 | 2.27611 |
[
"s547913071",
"s104997914"
] |
u581187895
|
p03178
|
python
|
s573932521
|
s618187089
| 1,071 | 834 | 162,700 | 157,332 |
Accepted
|
Accepted
| 22.13 |
def resolve():
MOD = 10**9+7
K = eval(input())
D = int(eval(input()))
N = len(K)
# dp[keta][D][smaler]
dp = [[[0]*2 for _ in range(D)] for _ in range(N+1)]
dp[0][0][0] = 1
for i in range(N):
num = int(K[i])
for j in range(D):
for smaller in range(2):
for d in range(10):
ni = i+1
nsmaller = smaller
nj = (j+d)%D
if smaller == 0:
if d < num:
nsmaller = 1
if d > num:
continue
dp[ni][nj][nsmaller] += dp[i][j][smaller]
dp[ni][nj][nsmaller] %= MOD
print(((dp[N][0][1] + dp[N][0][0] - 1) % MOD))
if __name__ == "__main__":
resolve()
|
def resolve():
MOD = 10**9+7
K = eval(input())
D = int(eval(input()))
N = len(K)
# dp[keta][D][smaler]
dp = [[[0]*2 for _ in range(D)] for _ in range(N+1)]
dp[0][0][0] = 1
for i in range(N):
for d in range(D):
# smaller=1 どの数字も使用できる
for k in range(10):
dp[i + 1][(d + k) % D][1] += dp[i][d][1]
dp[i + 1][(d + k) % D][1] %= MOD
# smaller=0 K[i]未満の数字のみ使用できる
# 次の遷移は繰り上げが無いのでどの数字も使用できる。smaller = 1
num = int(K[i])
for k in range(num):
dp[i + 1][(d + k) % D][1] += dp[i][d][0]
dp[i + 1][(d + k) % D][1] %= MOD
dp[i + 1][(d + num) % D][0] += dp[i][d][0]
dp[i + 1][(d + num) % D][0] %= MOD
print(((dp[N][0][0] + dp[N][0][1] - 1) % MOD))
if __name__ == "__main__":
resolve()
| 31 | 34 | 858 | 903 |
def resolve():
MOD = 10**9 + 7
K = eval(input())
D = int(eval(input()))
N = len(K)
# dp[keta][D][smaler]
dp = [[[0] * 2 for _ in range(D)] for _ in range(N + 1)]
dp[0][0][0] = 1
for i in range(N):
num = int(K[i])
for j in range(D):
for smaller in range(2):
for d in range(10):
ni = i + 1
nsmaller = smaller
nj = (j + d) % D
if smaller == 0:
if d < num:
nsmaller = 1
if d > num:
continue
dp[ni][nj][nsmaller] += dp[i][j][smaller]
dp[ni][nj][nsmaller] %= MOD
print(((dp[N][0][1] + dp[N][0][0] - 1) % MOD))
if __name__ == "__main__":
resolve()
|
def resolve():
MOD = 10**9 + 7
K = eval(input())
D = int(eval(input()))
N = len(K)
# dp[keta][D][smaler]
dp = [[[0] * 2 for _ in range(D)] for _ in range(N + 1)]
dp[0][0][0] = 1
for i in range(N):
for d in range(D):
# smaller=1 どの数字も使用できる
for k in range(10):
dp[i + 1][(d + k) % D][1] += dp[i][d][1]
dp[i + 1][(d + k) % D][1] %= MOD
# smaller=0 K[i]未満の数字のみ使用できる
# 次の遷移は繰り上げが無いのでどの数字も使用できる。smaller = 1
num = int(K[i])
for k in range(num):
dp[i + 1][(d + k) % D][1] += dp[i][d][0]
dp[i + 1][(d + k) % D][1] %= MOD
dp[i + 1][(d + num) % D][0] += dp[i][d][0]
dp[i + 1][(d + num) % D][0] %= MOD
print(((dp[N][0][0] + dp[N][0][1] - 1) % MOD))
if __name__ == "__main__":
resolve()
| false | 8.823529 |
[
"- num = int(K[i])",
"- for j in range(D):",
"- for smaller in range(2):",
"- for d in range(10):",
"- ni = i + 1",
"- nsmaller = smaller",
"- nj = (j + d) % D",
"- if smaller == 0:",
"- if d < num:",
"- nsmaller = 1",
"- if d > num:",
"- continue",
"- dp[ni][nj][nsmaller] += dp[i][j][smaller]",
"- dp[ni][nj][nsmaller] %= MOD",
"- print(((dp[N][0][1] + dp[N][0][0] - 1) % MOD))",
"+ for d in range(D):",
"+ # smaller=1 どの数字も使用できる",
"+ for k in range(10):",
"+ dp[i + 1][(d + k) % D][1] += dp[i][d][1]",
"+ dp[i + 1][(d + k) % D][1] %= MOD",
"+ # smaller=0 K[i]未満の数字のみ使用できる",
"+ # 次の遷移は繰り上げが無いのでどの数字も使用できる。smaller = 1",
"+ num = int(K[i])",
"+ for k in range(num):",
"+ dp[i + 1][(d + k) % D][1] += dp[i][d][0]",
"+ dp[i + 1][(d + k) % D][1] %= MOD",
"+ dp[i + 1][(d + num) % D][0] += dp[i][d][0]",
"+ dp[i + 1][(d + num) % D][0] %= MOD",
"+ print(((dp[N][0][0] + dp[N][0][1] - 1) % MOD))"
] | false | 0.036111 | 0.033188 | 1.088102 |
[
"s573932521",
"s618187089"
] |
u690536347
|
p02720
|
python
|
s301632712
|
s484604573
| 183 | 168 | 20,972 | 16,628 |
Accepted
|
Accepted
| 8.2 |
from collections import deque
def solve():
N = int(eval(input()))
q = deque([1,2,3,4,5,6,7,8,9])
cnt = 0
l = []
used = set()
while cnt<N:
p = q.popleft()
if p in used:continue
used.add(p)
l.append(p)
cnt += 1
for i in range(max((p%10)-1,0), min((p%10)+1, 9)+1):
q.append(10*p+i)
print((l[N-1]))
if __name__ == "__main__":
solve()
|
from collections import deque
def solve():
N = int(eval(input()))
q = deque([1,2,3,4,5,6,7,8,9])
cnt = 0
l = []
while cnt<N:
p = q.popleft()
l.append(p)
cnt += 1
for i in range(max((p%10)-1,0), min((p%10)+1, 9)+1):
q.append(10*p+i)
print((l[N-1]))
if __name__ == "__main__":
solve()
| 24 | 21 | 443 | 373 |
from collections import deque
def solve():
N = int(eval(input()))
q = deque([1, 2, 3, 4, 5, 6, 7, 8, 9])
cnt = 0
l = []
used = set()
while cnt < N:
p = q.popleft()
if p in used:
continue
used.add(p)
l.append(p)
cnt += 1
for i in range(max((p % 10) - 1, 0), min((p % 10) + 1, 9) + 1):
q.append(10 * p + i)
print((l[N - 1]))
if __name__ == "__main__":
solve()
|
from collections import deque
def solve():
N = int(eval(input()))
q = deque([1, 2, 3, 4, 5, 6, 7, 8, 9])
cnt = 0
l = []
while cnt < N:
p = q.popleft()
l.append(p)
cnt += 1
for i in range(max((p % 10) - 1, 0), min((p % 10) + 1, 9) + 1):
q.append(10 * p + i)
print((l[N - 1]))
if __name__ == "__main__":
solve()
| false | 12.5 |
[
"- used = set()",
"- if p in used:",
"- continue",
"- used.add(p)"
] | false | 0.065622 | 0.091313 | 0.718651 |
[
"s301632712",
"s484604573"
] |
u073852194
|
p03090
|
python
|
s831317973
|
s244352065
| 218 | 24 | 43,760 | 3,612 |
Accepted
|
Accepted
| 88.99 |
n = int(eval(input()))
C = [[1 for i in range(n)] for j in range(n)]
for i in range(n):
C[i][i] = 0
if n%2 == 0:
for i in range(n):
C[i][n-1-i] = 0
else:
for i in range(n):
C[i][n-2-i] = 0
print((n*(n-1)//2-n//2))
for i in range(n):
for j in range(n):
if i<j and C[i][j] == 1:
print((i+1,j+1))
|
N = int(eval(input()))
M = N * (N - 1) // 2 - N // 2
S = N // 2 * 2 + 1
print(M)
for i in range(1, N):
for j in range(i + 1, N + 1):
if i + j == S:
continue
print((i, j))
| 17 | 11 | 353 | 206 |
n = int(eval(input()))
C = [[1 for i in range(n)] for j in range(n)]
for i in range(n):
C[i][i] = 0
if n % 2 == 0:
for i in range(n):
C[i][n - 1 - i] = 0
else:
for i in range(n):
C[i][n - 2 - i] = 0
print((n * (n - 1) // 2 - n // 2))
for i in range(n):
for j in range(n):
if i < j and C[i][j] == 1:
print((i + 1, j + 1))
|
N = int(eval(input()))
M = N * (N - 1) // 2 - N // 2
S = N // 2 * 2 + 1
print(M)
for i in range(1, N):
for j in range(i + 1, N + 1):
if i + j == S:
continue
print((i, j))
| false | 35.294118 |
[
"-n = int(eval(input()))",
"-C = [[1 for i in range(n)] for j in range(n)]",
"-for i in range(n):",
"- C[i][i] = 0",
"-if n % 2 == 0:",
"- for i in range(n):",
"- C[i][n - 1 - i] = 0",
"-else:",
"- for i in range(n):",
"- C[i][n - 2 - i] = 0",
"-print((n * (n - 1) // 2 - n // 2))",
"-for i in range(n):",
"- for j in range(n):",
"- if i < j and C[i][j] == 1:",
"- print((i + 1, j + 1))",
"+N = int(eval(input()))",
"+M = N * (N - 1) // 2 - N // 2",
"+S = N // 2 * 2 + 1",
"+print(M)",
"+for i in range(1, N):",
"+ for j in range(i + 1, N + 1):",
"+ if i + j == S:",
"+ continue",
"+ print((i, j))"
] | false | 0.043863 | 0.058657 | 0.74779 |
[
"s831317973",
"s244352065"
] |
u190086340
|
p04013
|
python
|
s881956302
|
s775021720
| 833 | 621 | 120,924 | 58,932 |
Accepted
|
Accepted
| 25.45 |
def solve():
def recur(i, n, total):
# print("i, n, total", i, n, total)
if not TABLE[i][n][total] == -1:
# print('cache!')
return TABLE[i][n][total]
if not i < N:
if n > 0 and total == A * n:
return 1
return 0
ans1 = recur(i + 1, n, total)
ans2 = recur(i + 1, n + 1, total + XS[i])
# print(ans1, ans2)
TABLE[i][n][total] = ans1 + ans2
return TABLE[i][n][total]
N, A = tuple(map(int, input().split()))
XS = tuple(map(int, input().split()))
TABLE = []
for _ in range(N + 1):
lines = [[-1 for x in range(N * 50 + 1)] for y in range(N + 1)]
TABLE.append(lines)
return recur(0, 0, 0)
if __name__ == '__main__':
print((solve()))
|
def solve():
def recur(i, n, total):
# print("i, n, total", i, n, total)
if not TABLE[i][n][total] == -1:
return TABLE[i][n][total]
if not i < N:
if n > 0 and total == A * n:
TABLE[i][n][total] = 1
return TABLE[i][n][total]
TABLE[i][n][total] = 0
return TABLE[i][n][total]
ans1 = recur(i + 1, n, total)
ans2 = recur(i + 1, n + 1, total + XS[i])
# print(ans1, ans2)
TABLE[i][n][total] = ans1 + ans2
return TABLE[i][n][total]
N, A = tuple(map(int, input().split()))
XS = tuple(map(int, input().split()))
TABLE = []
for _ in range(N + 1):
lines = [[-1 for x in range(N * 50 + 1)] for y in range(N + 1)]
TABLE.append(lines)
return recur(0, 0, 0)
if __name__ == '__main__':
print((solve()))
| 34 | 36 | 837 | 918 |
def solve():
def recur(i, n, total):
# print("i, n, total", i, n, total)
if not TABLE[i][n][total] == -1:
# print('cache!')
return TABLE[i][n][total]
if not i < N:
if n > 0 and total == A * n:
return 1
return 0
ans1 = recur(i + 1, n, total)
ans2 = recur(i + 1, n + 1, total + XS[i])
# print(ans1, ans2)
TABLE[i][n][total] = ans1 + ans2
return TABLE[i][n][total]
N, A = tuple(map(int, input().split()))
XS = tuple(map(int, input().split()))
TABLE = []
for _ in range(N + 1):
lines = [[-1 for x in range(N * 50 + 1)] for y in range(N + 1)]
TABLE.append(lines)
return recur(0, 0, 0)
if __name__ == "__main__":
print((solve()))
|
def solve():
def recur(i, n, total):
# print("i, n, total", i, n, total)
if not TABLE[i][n][total] == -1:
return TABLE[i][n][total]
if not i < N:
if n > 0 and total == A * n:
TABLE[i][n][total] = 1
return TABLE[i][n][total]
TABLE[i][n][total] = 0
return TABLE[i][n][total]
ans1 = recur(i + 1, n, total)
ans2 = recur(i + 1, n + 1, total + XS[i])
# print(ans1, ans2)
TABLE[i][n][total] = ans1 + ans2
return TABLE[i][n][total]
N, A = tuple(map(int, input().split()))
XS = tuple(map(int, input().split()))
TABLE = []
for _ in range(N + 1):
lines = [[-1 for x in range(N * 50 + 1)] for y in range(N + 1)]
TABLE.append(lines)
return recur(0, 0, 0)
if __name__ == "__main__":
print((solve()))
| false | 5.555556 |
[
"- # print('cache!')",
"- return 1",
"- return 0",
"+ TABLE[i][n][total] = 1",
"+ return TABLE[i][n][total]",
"+ TABLE[i][n][total] = 0",
"+ return TABLE[i][n][total]"
] | false | 0.046695 | 0.078339 | 0.59606 |
[
"s881956302",
"s775021720"
] |
u389910364
|
p02757
|
python
|
s488115499
|
s333115313
| 394 | 277 | 20,616 | 31,772 |
Accepted
|
Accepted
| 29.7 |
import itertools
import os
import sys
if os.getenv("LOCAL"):
sys.stdin = open("_in.txt", "r")
sys.setrecursionlimit(10 ** 9)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7
# MOD = 998244353
def toint(l, r):
return int(''.join(map(str, S[l:r])))
def test():
ans = 0
for l, r in itertools.combinations_with_replacement(list(range(N)), r=2):
s = toint(l, r + 1)
ans += s % P == 0
print(ans)
def solve25():
ret = 0
for d in range(N):
if S[d] % P == 0:
ret += d + 1
return ret
def mod_invs(max, mod):
"""
逆元 0, 1/1, 1/2, 1/3, ..., 1/max
:param int max:
:param int mod:
"""
invs = [1] * (max + 1)
invs[0] = 0
for x in range(2, max + 1):
invs[x] = (-(mod // x) * invs[mod % x]) % mod
return invs
N, P = list(map(int, sys.stdin.buffer.readline().split()))
S = list(map(int, list(sys.stdin.buffer.readline().decode().rstrip())))
# 10 mod P で割れない
if P in [2, 5]:
ans = solve25()
print(ans)
exit()
# test()
powers = []
p = 1
for _ in range(N):
powers.append(p)
p = p * 10 % P
# int(S[1:1]), int(S[1:2]), int(S[1:3]), ...
s_additions = [0]
s = 0
for i in range(1, N):
s = (s * 10 + S[i]) % P
s_additions.append(s)
invs = mod_invs(max=P - 1, mod=P)
def to_index(i, p):
# もともと x だったのが、i 番目で p になっているときの x を返す
if i == 0:
return p % P
return (p - s_additions[i]) * invs[powers[i]] % P
mod_counts = [0] * P
ans = 0
for i, c in enumerate(S):
mod_counts[to_index(i, c)] += 1
ans += mod_counts[to_index(i, 0)]
print(ans)
|
import os
import sys
if os.getenv("LOCAL"):
sys.stdin = open("_in.txt", "r")
sys.setrecursionlimit(10 ** 9)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7
# MOD = 998244353
# 解説
# P で割り切れるなら 10^n で割っても割り切れる。
N, P = list(map(int, sys.stdin.buffer.readline().split()))
S = sys.stdin.buffer.readline().decode().rstrip()
def solve25():
ans = 0
for i, c in enumerate(S):
if int(c) % P == 0:
ans += i + 1
return ans
if P in (2, 5):
ans = solve25()
print(ans)
exit()
# U[i]: int(S[i:]) % P
U = [0] * N
n = 0
p = 1
for i, c in reversed(list(enumerate(S))):
n += int(c) * p
n %= P
U[i] = n
p *= 10
p %= P
counts = [0] * P
for u in U:
counts[u] += 1
ans = counts[0]
for i in reversed(list(range(N))):
# U[i] を引いたときに 0 (mod P) となる数
counts[U[i]] -= 1
ans += counts[U[i]]
print(ans)
| 87 | 53 | 1,676 | 917 |
import itertools
import os
import sys
if os.getenv("LOCAL"):
sys.stdin = open("_in.txt", "r")
sys.setrecursionlimit(10**9)
INF = float("inf")
IINF = 10**18
MOD = 10**9 + 7
# MOD = 998244353
def toint(l, r):
return int("".join(map(str, S[l:r])))
def test():
ans = 0
for l, r in itertools.combinations_with_replacement(list(range(N)), r=2):
s = toint(l, r + 1)
ans += s % P == 0
print(ans)
def solve25():
ret = 0
for d in range(N):
if S[d] % P == 0:
ret += d + 1
return ret
def mod_invs(max, mod):
"""
逆元 0, 1/1, 1/2, 1/3, ..., 1/max
:param int max:
:param int mod:
"""
invs = [1] * (max + 1)
invs[0] = 0
for x in range(2, max + 1):
invs[x] = (-(mod // x) * invs[mod % x]) % mod
return invs
N, P = list(map(int, sys.stdin.buffer.readline().split()))
S = list(map(int, list(sys.stdin.buffer.readline().decode().rstrip())))
# 10 mod P で割れない
if P in [2, 5]:
ans = solve25()
print(ans)
exit()
# test()
powers = []
p = 1
for _ in range(N):
powers.append(p)
p = p * 10 % P
# int(S[1:1]), int(S[1:2]), int(S[1:3]), ...
s_additions = [0]
s = 0
for i in range(1, N):
s = (s * 10 + S[i]) % P
s_additions.append(s)
invs = mod_invs(max=P - 1, mod=P)
def to_index(i, p):
# もともと x だったのが、i 番目で p になっているときの x を返す
if i == 0:
return p % P
return (p - s_additions[i]) * invs[powers[i]] % P
mod_counts = [0] * P
ans = 0
for i, c in enumerate(S):
mod_counts[to_index(i, c)] += 1
ans += mod_counts[to_index(i, 0)]
print(ans)
|
import os
import sys
if os.getenv("LOCAL"):
sys.stdin = open("_in.txt", "r")
sys.setrecursionlimit(10**9)
INF = float("inf")
IINF = 10**18
MOD = 10**9 + 7
# MOD = 998244353
# 解説
# P で割り切れるなら 10^n で割っても割り切れる。
N, P = list(map(int, sys.stdin.buffer.readline().split()))
S = sys.stdin.buffer.readline().decode().rstrip()
def solve25():
ans = 0
for i, c in enumerate(S):
if int(c) % P == 0:
ans += i + 1
return ans
if P in (2, 5):
ans = solve25()
print(ans)
exit()
# U[i]: int(S[i:]) % P
U = [0] * N
n = 0
p = 1
for i, c in reversed(list(enumerate(S))):
n += int(c) * p
n %= P
U[i] = n
p *= 10
p %= P
counts = [0] * P
for u in U:
counts[u] += 1
ans = counts[0]
for i in reversed(list(range(N))):
# U[i] を引いたときに 0 (mod P) となる数
counts[U[i]] -= 1
ans += counts[U[i]]
print(ans)
| false | 39.08046 |
[
"-import itertools",
"-def toint(l, r):",
"- return int(\"\".join(map(str, S[l:r])))",
"-",
"-",
"-def test():",
"- ans = 0",
"- for l, r in itertools.combinations_with_replacement(list(range(N)), r=2):",
"- s = toint(l, r + 1)",
"- ans += s % P == 0",
"- print(ans)",
"+# 解説",
"+# P で割り切れるなら 10^n で割っても割り切れる。",
"+N, P = list(map(int, sys.stdin.buffer.readline().split()))",
"+S = sys.stdin.buffer.readline().decode().rstrip()",
"- ret = 0",
"- for d in range(N):",
"- if S[d] % P == 0:",
"- ret += d + 1",
"- return ret",
"+ ans = 0",
"+ for i, c in enumerate(S):",
"+ if int(c) % P == 0:",
"+ ans += i + 1",
"+ return ans",
"-def mod_invs(max, mod):",
"- \"\"\"",
"- 逆元 0, 1/1, 1/2, 1/3, ..., 1/max",
"- :param int max:",
"- :param int mod:",
"- \"\"\"",
"- invs = [1] * (max + 1)",
"- invs[0] = 0",
"- for x in range(2, max + 1):",
"- invs[x] = (-(mod // x) * invs[mod % x]) % mod",
"- return invs",
"-",
"-",
"-N, P = list(map(int, sys.stdin.buffer.readline().split()))",
"-S = list(map(int, list(sys.stdin.buffer.readline().decode().rstrip())))",
"-# 10 mod P で割れない",
"-if P in [2, 5]:",
"+if P in (2, 5):",
"-# test()",
"-powers = []",
"+# U[i]: int(S[i:]) % P",
"+U = [0] * N",
"+n = 0",
"-for _ in range(N):",
"- powers.append(p)",
"- p = p * 10 % P",
"-# int(S[1:1]), int(S[1:2]), int(S[1:3]), ...",
"-s_additions = [0]",
"-s = 0",
"-for i in range(1, N):",
"- s = (s * 10 + S[i]) % P",
"- s_additions.append(s)",
"-invs = mod_invs(max=P - 1, mod=P)",
"-",
"-",
"-def to_index(i, p):",
"- # もともと x だったのが、i 番目で p になっているときの x を返す",
"- if i == 0:",
"- return p % P",
"- return (p - s_additions[i]) * invs[powers[i]] % P",
"-",
"-",
"-mod_counts = [0] * P",
"-ans = 0",
"-for i, c in enumerate(S):",
"- mod_counts[to_index(i, c)] += 1",
"- ans += mod_counts[to_index(i, 0)]",
"+for i, c in reversed(list(enumerate(S))):",
"+ n += int(c) * p",
"+ n %= P",
"+ U[i] = n",
"+ p *= 10",
"+ p %= P",
"+counts = [0] * P",
"+for u in U:",
"+ counts[u] += 1",
"+ans = counts[0]",
"+for i in reversed(list(range(N))):",
"+ # U[i] を引いたときに 0 (mod P) となる数",
"+ counts[U[i]] -= 1",
"+ ans += counts[U[i]]"
] | false | 0.052619 | 0.106723 | 0.493041 |
[
"s488115499",
"s333115313"
] |
u923279197
|
p02924
|
python
|
s116782990
|
s495941493
| 166 | 17 | 38,256 | 2,940 |
Accepted
|
Accepted
| 89.76 |
n = int(eval(input()))
print((n*(n-1)//2))
|
n = int(eval(input()))
print(((n - 1) * n // 2))
| 2 | 2 | 35 | 41 |
n = int(eval(input()))
print((n * (n - 1) // 2))
|
n = int(eval(input()))
print(((n - 1) * n // 2))
| false | 0 |
[
"-print((n * (n - 1) // 2))",
"+print(((n - 1) * n // 2))"
] | false | 0.063274 | 0.038157 | 1.658231 |
[
"s116782990",
"s495941493"
] |
u312025627
|
p02599
|
python
|
s899697094
|
s369957887
| 1,542 | 1,422 | 203,352 | 187,152 |
Accepted
|
Accepted
| 7.78 |
class fenwick_tree:
"""
区間の一点更新と，区間和の取得がO(log n)で可能なデータ構造
1-indexedで実装
"""
def __init__(self, N):
self.size = N
self.tree = [0] * (N+1)
def sum_until(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & (-i)
return s
def sum_acc(self, i, j):
""" [i,j] の和を返す """
return self.sum_until(j) - self.sum_until(i-1)
def add(self, i, x):
if i <= 0:
return
while i <= self.size:
self.tree[i] += x
i += i & (-i)
def main():
N, Q = (int(i) for i in input().split())
C = [int(i) for i in input().split()]
Query = [[] for _ in range(N+1)]
for j in range(Q):
le, ri = (int(i) for i in input().split())
Query[ri].append((le, j))
Query.append((-1, -1, -1))
lastappend = [-1] * (N + 1)
bit = fenwick_tree(N)
ans = [0]*Q
for i, a in enumerate(C, start=1):
if lastappend[a] != -1:
bit.add(lastappend[a], -1)
lastappend[a] = i
bit.add(i, 1)
for (le, j) in Query[i]:
ri = i
ans[j] = bit.sum_acc(le, ri)
print(*ans, sep="\n")
if __name__ == '__main__':
main()
|
class fenwick_tree:
"""
区間の一点更新と，区間和の取得がO(log n)で可能なデータ構造
1-indexedで実装
"""
def __init__(self, N):
self.size = N
self.tree = [0] * (N+1)
def sum_until(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & (-i)
return s
def sum_acc(self, i, j):
""" [i,j] の和を返す """
return self.sum_until(j) - self.sum_until(i-1)
def add(self, i, x):
if i <= 0:
return
while i <= self.size:
self.tree[i] += x
i += i & (-i)
def main():
N, Q = (int(i) for i in input().split())
C = [int(i) for i in input().split()]
Query = [[] for _ in range(N+1)]
for j in range(Q):
le, ri = (int(i) for i in input().split())
Query[ri].append((le, j))
lastappend = [-1] * (N + 1)
bit = fenwick_tree(N)
ans = [0]*Q
for i, a in enumerate(C, start=1):
if lastappend[a] != -1:
bit.add(lastappend[a], -1)
lastappend[a] = i
bit.add(i, 1)
for (le, j) in Query[i]:
ri = i
ans[j] = bit.sum_acc(le, ri)
print(*ans, sep="\n")
if __name__ == '__main__':
main()
| 57 | 55 | 1,301 | 1,267 |
class fenwick_tree:
"""
区間の一点更新と，区間和の取得がO(log n)で可能なデータ構造
1-indexedで実装
"""
def __init__(self, N):
self.size = N
self.tree = [0] * (N + 1)
def sum_until(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & (-i)
return s
def sum_acc(self, i, j):
"""[i,j] の和を返す"""
return self.sum_until(j) - self.sum_until(i - 1)
def add(self, i, x):
if i <= 0:
return
while i <= self.size:
self.tree[i] += x
i += i & (-i)
def main():
N, Q = (int(i) for i in input().split())
C = [int(i) for i in input().split()]
Query = [[] for _ in range(N + 1)]
for j in range(Q):
le, ri = (int(i) for i in input().split())
Query[ri].append((le, j))
Query.append((-1, -1, -1))
lastappend = [-1] * (N + 1)
bit = fenwick_tree(N)
ans = [0] * Q
for i, a in enumerate(C, start=1):
if lastappend[a] != -1:
bit.add(lastappend[a], -1)
lastappend[a] = i
bit.add(i, 1)
for (le, j) in Query[i]:
ri = i
ans[j] = bit.sum_acc(le, ri)
print(*ans, sep="\n")
if __name__ == "__main__":
main()
|
class fenwick_tree:
"""
区間の一点更新と，区間和の取得がO(log n)で可能なデータ構造
1-indexedで実装
"""
def __init__(self, N):
self.size = N
self.tree = [0] * (N + 1)
def sum_until(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & (-i)
return s
def sum_acc(self, i, j):
"""[i,j] の和を返す"""
return self.sum_until(j) - self.sum_until(i - 1)
def add(self, i, x):
if i <= 0:
return
while i <= self.size:
self.tree[i] += x
i += i & (-i)
def main():
N, Q = (int(i) for i in input().split())
C = [int(i) for i in input().split()]
Query = [[] for _ in range(N + 1)]
for j in range(Q):
le, ri = (int(i) for i in input().split())
Query[ri].append((le, j))
lastappend = [-1] * (N + 1)
bit = fenwick_tree(N)
ans = [0] * Q
for i, a in enumerate(C, start=1):
if lastappend[a] != -1:
bit.add(lastappend[a], -1)
lastappend[a] = i
bit.add(i, 1)
for (le, j) in Query[i]:
ri = i
ans[j] = bit.sum_acc(le, ri)
print(*ans, sep="\n")
if __name__ == "__main__":
main()
| false | 3.508772 |
[
"- Query.append((-1, -1, -1))"
] | false | 0.04847 | 0.045542 | 1.064296 |
[
"s899697094",
"s369957887"
] |
u074220993
|
p03435
|
python
|
s807326785
|
s372320717
| 119 | 26 | 27,040 | 9,068 |
Accepted
|
Accepted
| 78.15 |
import numpy as np
C = np.array([[int(x) for x in input().split()] for _ in range(3)])
ans = 'Yes'
for i in range(2):
if not(C[0,i+1]-C[0,i] == C[1,i+1]-C[1,i] == C[2,i+1]-C[2,i]):
ans = 'No'
if not(C[i+1,0]-C[i,0] == C[i+1,1]-C[i,1] == C[i+1,2]-C[i,2]):
ans = 'No'
print(ans)
|
with open(0) as f:
C = [list(map(int, line.split())) for line in f.readlines()]
b = [(C[i][1]-C[i][0], C[i][2]-C[i][1]) for i in range(3)]
a = [(C[1][j]-C[0][j], C[2][j]-C[1][j]) for j in range(3)]
print(('Yes' if a[0]==a[1]==a[2] and b[0]==b[1]==b[2] else 'No'))
| 9 | 5 | 309 | 269 |
import numpy as np
C = np.array([[int(x) for x in input().split()] for _ in range(3)])
ans = "Yes"
for i in range(2):
if not (C[0, i + 1] - C[0, i] == C[1, i + 1] - C[1, i] == C[2, i + 1] - C[2, i]):
ans = "No"
if not (C[i + 1, 0] - C[i, 0] == C[i + 1, 1] - C[i, 1] == C[i + 1, 2] - C[i, 2]):
ans = "No"
print(ans)
|
with open(0) as f:
C = [list(map(int, line.split())) for line in f.readlines()]
b = [(C[i][1] - C[i][0], C[i][2] - C[i][1]) for i in range(3)]
a = [(C[1][j] - C[0][j], C[2][j] - C[1][j]) for j in range(3)]
print(("Yes" if a[0] == a[1] == a[2] and b[0] == b[1] == b[2] else "No"))
| false | 44.444444 |
[
"-import numpy as np",
"-",
"-C = np.array([[int(x) for x in input().split()] for _ in range(3)])",
"-ans = \"Yes\"",
"-for i in range(2):",
"- if not (C[0, i + 1] - C[0, i] == C[1, i + 1] - C[1, i] == C[2, i + 1] - C[2, i]):",
"- ans = \"No\"",
"- if not (C[i + 1, 0] - C[i, 0] == C[i + 1, 1] - C[i, 1] == C[i + 1, 2] - C[i, 2]):",
"- ans = \"No\"",
"-print(ans)",
"+with open(0) as f:",
"+ C = [list(map(int, line.split())) for line in f.readlines()]",
"+b = [(C[i][1] - C[i][0], C[i][2] - C[i][1]) for i in range(3)]",
"+a = [(C[1][j] - C[0][j], C[2][j] - C[1][j]) for j in range(3)]",
"+print((\"Yes\" if a[0] == a[1] == a[2] and b[0] == b[1] == b[2] else \"No\"))"
] | false | 0.340806 | 0.072066 | 4.729106 |
[
"s807326785",
"s372320717"
] |
u197615397
|
p02315
|
python
|
s104133132
|
s141188244
| 1,290 | 540 | 25,096 | 8,928 |
Accepted
|
Accepted
| 58.14 |
import sys
readline = sys.stdin.readline
N, W = list(map(int, readline().split()))
a = [(v, w) for _ in [None]*N for v, w in (list(map(int, readline().split())),)]
dp = [[0]*(W+1) for _ in [None]*(N+1)]
dp[0][0] = 0
weight = {0}
for i in range(N):
item_value, item_weight = a[i]
for w in weight.copy():
dp[i+1][w] = dp[i+1][w] if dp[i+1][w] > dp[i][w] else dp[i][w]
nvalue = dp[i][w] + item_value
if w+item_weight <= W:
dp[i+1][w+item_weight] = nvalue if nvalue > dp[i+1][w+item_weight] else dp[i+1][w+item_weight]
weight.add(w+item_weight)
print((max(dp[N])))
|
import sys
readline = sys.stdin.readline
N, W = list(map(int, readline().split()))
dp = [0] * (W+1)
weights = {0}
add = weights.add
for i in range(N):
item_v, item_w = list(map(int, readline().split()))
for w in sorted(weights, reverse=True):
if w+item_w <= W and dp[w+item_w] < dp[w] + item_v:
dp[w+item_w] = dp[w] + item_v
add(w+item_w)
print((max(dp)))
| 20 | 17 | 625 | 401 |
import sys
readline = sys.stdin.readline
N, W = list(map(int, readline().split()))
a = [(v, w) for _ in [None] * N for v, w in (list(map(int, readline().split())),)]
dp = [[0] * (W + 1) for _ in [None] * (N + 1)]
dp[0][0] = 0
weight = {0}
for i in range(N):
item_value, item_weight = a[i]
for w in weight.copy():
dp[i + 1][w] = dp[i + 1][w] if dp[i + 1][w] > dp[i][w] else dp[i][w]
nvalue = dp[i][w] + item_value
if w + item_weight <= W:
dp[i + 1][w + item_weight] = (
nvalue
if nvalue > dp[i + 1][w + item_weight]
else dp[i + 1][w + item_weight]
)
weight.add(w + item_weight)
print((max(dp[N])))
|
import sys
readline = sys.stdin.readline
N, W = list(map(int, readline().split()))
dp = [0] * (W + 1)
weights = {0}
add = weights.add
for i in range(N):
item_v, item_w = list(map(int, readline().split()))
for w in sorted(weights, reverse=True):
if w + item_w <= W and dp[w + item_w] < dp[w] + item_v:
dp[w + item_w] = dp[w] + item_v
add(w + item_w)
print((max(dp)))
| false | 15 |
[
"-a = [(v, w) for _ in [None] * N for v, w in (list(map(int, readline().split())),)]",
"-dp = [[0] * (W + 1) for _ in [None] * (N + 1)]",
"-dp[0][0] = 0",
"-weight = {0}",
"+dp = [0] * (W + 1)",
"+weights = {0}",
"+add = weights.add",
"- item_value, item_weight = a[i]",
"- for w in weight.copy():",
"- dp[i + 1][w] = dp[i + 1][w] if dp[i + 1][w] > dp[i][w] else dp[i][w]",
"- nvalue = dp[i][w] + item_value",
"- if w + item_weight <= W:",
"- dp[i + 1][w + item_weight] = (",
"- nvalue",
"- if nvalue > dp[i + 1][w + item_weight]",
"- else dp[i + 1][w + item_weight]",
"- )",
"- weight.add(w + item_weight)",
"-print((max(dp[N])))",
"+ item_v, item_w = list(map(int, readline().split()))",
"+ for w in sorted(weights, reverse=True):",
"+ if w + item_w <= W and dp[w + item_w] < dp[w] + item_v:",
"+ dp[w + item_w] = dp[w] + item_v",
"+ add(w + item_w)",
"+print((max(dp)))"
] | false | 0.0414 | 0.039879 | 1.038133 |
[
"s104133132",
"s141188244"
] |
u102461423
|
p03838
|
python
|
s545013103
|
s471963285
| 19 | 17 | 3,064 | 3,064 |
Accepted
|
Accepted
| 10.53 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
x,y = list(map(int,input().split()))
answer = 10 ** 18
if x <= y:
answer = min(answer, y-x)
if -x <= y:
answer = min(answer, 1+x+y)
if x <= -y:
answer = min(answer, 1-y-x)
if -x <= -y:
answer = min(answer, 2+x-y)
print(answer)
|
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
# 符号の反転は最初と最後以外にない
x,y = list(map(int,read().split()))
cand = []
if x <= y:
cand.append(y-x)
if (-x) <= y:
cand.append(1 + x + y)
if x <= (-y):
cand.append(1 - x - y)
if (-x) <= (-y):
cand.append(2 - y + x)
answer = min(cand)
print(answer)
| 15 | 21 | 320 | 389 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
x, y = list(map(int, input().split()))
answer = 10**18
if x <= y:
answer = min(answer, y - x)
if -x <= y:
answer = min(answer, 1 + x + y)
if x <= -y:
answer = min(answer, 1 - y - x)
if -x <= -y:
answer = min(answer, 2 + x - y)
print(answer)
|
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
# 符号の反転は最初と最後以外にない
x, y = list(map(int, read().split()))
cand = []
if x <= y:
cand.append(y - x)
if (-x) <= y:
cand.append(1 + x + y)
if x <= (-y):
cand.append(1 - x - y)
if (-x) <= (-y):
cand.append(2 - y + x)
answer = min(cand)
print(answer)
| false | 28.571429 |
[
"-input = sys.stdin.readline",
"-sys.setrecursionlimit(10**7)",
"-x, y = list(map(int, input().split()))",
"-answer = 10**18",
"+read = sys.stdin.buffer.read",
"+readline = sys.stdin.buffer.readline",
"+readlines = sys.stdin.buffer.readlines",
"+# 符号の反転は最初と最後以外にない",
"+x, y = list(map(int, read().split()))",
"+cand = []",
"- answer = min(answer, y - x)",
"-if -x <= y:",
"- answer = min(answer, 1 + x + y)",
"-if x <= -y:",
"- answer = min(answer, 1 - y - x)",
"-if -x <= -y:",
"- answer = min(answer, 2 + x - y)",
"+ cand.append(y - x)",
"+if (-x) <= y:",
"+ cand.append(1 + x + y)",
"+if x <= (-y):",
"+ cand.append(1 - x - y)",
"+if (-x) <= (-y):",
"+ cand.append(2 - y + x)",
"+answer = min(cand)"
] | false | 0.061883 | 0.061269 | 1.010023 |
[
"s545013103",
"s471963285"
] |
u844789719
|
p03253
|
python
|
s313675527
|
s297579047
| 26 | 22 | 3,188 | 3,064 |
Accepted
|
Accepted
| 15.38 |
N, M = [int(_) for _ in input().split()]
mod = 10 ** 9 + 7
def comb(x, y):
if y * 2 > x:
y = x - y
result = 1
for j in range(1, y + 1):
result *= (x + j - y)
result //= j
return result
def homoprod(x, y):
return comb(x + y - 1, y)
ans = 1
i = 2
for i in range(2, int(M ** 0.5) + 2):
count = 0
while M % i == 0:
count += 1
M //= i
if count > 0:
ans *= homoprod(N, count)
ans %= mod
if M > 1:
ans *= homoprod(N, 1)
ans %= mod
print(ans)
|
N, M = [int(_) for _ in input().split()]
mod = 10 ** 9 + 7
def comb(x, y):
if y * 2 > x:
y = x - y
result = 1
for j in range(1, y + 1):
result *= (x + j - y) * pow(j, mod - 2, mod)
result %= mod
return result
def homoprod(x, y):
return comb(x + y - 1, y)
ans = 1
i = 2
for i in range(2, int(M ** 0.5) + 2):
count = 0
while M % i == 0:
count += 1
M //= i
if count > 0:
ans *= homoprod(N, count)
ans %= mod
if M > 1:
ans *= homoprod(N, 1)
ans %= mod
print(ans)
| 28 | 28 | 560 | 584 |
N, M = [int(_) for _ in input().split()]
mod = 10**9 + 7
def comb(x, y):
if y * 2 > x:
y = x - y
result = 1
for j in range(1, y + 1):
result *= x + j - y
result //= j
return result
def homoprod(x, y):
return comb(x + y - 1, y)
ans = 1
i = 2
for i in range(2, int(M**0.5) + 2):
count = 0
while M % i == 0:
count += 1
M //= i
if count > 0:
ans *= homoprod(N, count)
ans %= mod
if M > 1:
ans *= homoprod(N, 1)
ans %= mod
print(ans)
|
N, M = [int(_) for _ in input().split()]
mod = 10**9 + 7
def comb(x, y):
if y * 2 > x:
y = x - y
result = 1
for j in range(1, y + 1):
result *= (x + j - y) * pow(j, mod - 2, mod)
result %= mod
return result
def homoprod(x, y):
return comb(x + y - 1, y)
ans = 1
i = 2
for i in range(2, int(M**0.5) + 2):
count = 0
while M % i == 0:
count += 1
M //= i
if count > 0:
ans *= homoprod(N, count)
ans %= mod
if M > 1:
ans *= homoprod(N, 1)
ans %= mod
print(ans)
| false | 0 |
[
"- result *= x + j - y",
"- result //= j",
"+ result *= (x + j - y) * pow(j, mod - 2, mod)",
"+ result %= mod"
] | false | 0.126719 | 0.054771 | 2.313631 |
[
"s313675527",
"s297579047"
] |
u760831084
|
p03970
|
python
|
s425090801
|
s151008063
| 32 | 27 | 9,052 | 9,012 |
Accepted
|
Accepted
| 15.62 |
s = eval(input())
a = 'CODEFESTIVAL2016'
cnt = 0
for i in range(16):
if s[i] != a[i]:
cnt += 1
print(cnt)
|
s = eval(input())
t = 'CODEFESTIVAL2016'
a = sum(c1 != c2 for c1, c2 in zip(s, t))
print(a)
| 7 | 4 | 117 | 88 |
s = eval(input())
a = "CODEFESTIVAL2016"
cnt = 0
for i in range(16):
if s[i] != a[i]:
cnt += 1
print(cnt)
|
s = eval(input())
t = "CODEFESTIVAL2016"
a = sum(c1 != c2 for c1, c2 in zip(s, t))
print(a)
| false | 42.857143 |
[
"-a = \"CODEFESTIVAL2016\"",
"-cnt = 0",
"-for i in range(16):",
"- if s[i] != a[i]:",
"- cnt += 1",
"-print(cnt)",
"+t = \"CODEFESTIVAL2016\"",
"+a = sum(c1 != c2 for c1, c2 in zip(s, t))",
"+print(a)"
] | false | 0.034735 | 0.035312 | 0.983667 |
[
"s425090801",
"s151008063"
] |
u467736898
|
p02868
|
python
|
s326073140
|
s926866848
| 1,222 | 1,010 | 103,892 | 72,024 |
Accepted
|
Accepted
| 17.35 |
# 抽象化をやめる
class Rmq(object):
__slots__ = ["elem_size", "tree", "real_size"]
def __init__(self, a):
if hasattr(a, "__iter__"):
self.real_size = len(a)
self.elem_size = elem_size = 1 << (self.real_size-1).bit_length()
self.tree = tree = [float("inf")] * (elem_size * 2)
tree[elem_size:elem_size + self.real_size] = a
for i in range(elem_size - 1, 0, -1):
tree[i] = min(tree[i << 1], tree[(i << 1) + 1])
elif isinstance(a, int):
self.real_size = a
self.elem_size = elem_size = 1 << (self.real_size-1).bit_length()
self.tree = [float("inf")] * (elem_size * 2)
def get_value(self, x: int, y: int) -> int: # 半開区間
l, r = x + self.elem_size, y + self.elem_size
tree = self.tree
result = float("inf")
while l < r:
if l & 1:
result = min(tree[l], result)
l += 1
if r & 1:
r -= 1
result = min(tree[r], result)
l, r = l >> 1, r >> 1
return result
def set_value(self, i: int, value: int) -> None:
k = self.elem_size + i
tree = self.tree
tree[k] = value
while k > 1:
k >>= 1
tree[k] = min(tree[k << 1], tree[(k << 1) + 1])
def get_one_value(self, i):
return self.tree[i+self.elem_size]
def debug(self):
print((self.tree[self.elem_size:self.elem_size+self.real_size]))
from operator import itemgetter
N, M = list(map(int, input().split()))
LRC = [list(map(int, input().split())) for _ in range(M)]
LRC.sort(key=itemgetter(0))
idx_LRC = 0
q = []
seg = Rmq(N+1)
seg.set_value(1, 0)
for v in range(1, N + 1):
d = seg.get_value(v, N + 1)
while idx_LRC < M:
l, r, c = LRC[idx_LRC]
if l <= v:
seg.set_value(r, min(seg.tree[r + seg.elem_size], d + c))
idx_LRC += 1
else:
break
ans = seg.tree[N + seg.elem_size]
print((ans if ans != float("inf") else -1))
|
# RMQ のパフォーマンステスト
class Rmq:
# 平方分割
# 値を変更すると元のリストの値も書き換わる
# 検証: http://judge.u-aizu.ac.jp/onlinejudge/review.jsp?rid=3990681
def __init__(self, a, sqrt_n=150, inf=(1<<31)-1):
self.sqrt_n = sqrt_n
if hasattr(a, "__iter__"):
from itertools import zip_longest
self.n = len(a)
self.layer0 = [min(values) for values in zip_longest(*[iter(a)]*sqrt_n, fillvalue=inf)]
self.layer1 = a
elif isinstance(a, int):
self.n = a
self.layer0 = [inf] * ((a - 1) // sqrt_n + 1)
self.layer1 = [inf] * a
else:
raise TypeError
def get_min(self, l, r):
sqrt_n = self.sqrt_n
parent_l, parent_r = l//sqrt_n+1, (r-1)//sqrt_n
if parent_l < parent_r:
return min(min(self.layer0[parent_l:parent_r]),
min(self.layer1[l:parent_l*sqrt_n]),
min(self.layer1[parent_r*sqrt_n:r]))
else:
return min(self.layer1[l:r])
def set_value(self, idx, val):
self.layer1[idx] = val
idx0 = idx // self.sqrt_n
idx1 = idx0 * self.sqrt_n
self.layer0[idx0] = min(self.layer1[idx1:idx1+self.sqrt_n])
def chmin(self, idx, val):
if self.layer1[idx] > val:
self.layer1[idx] = val
idx //= self.sqrt_n
self.layer0[idx] = min(self.layer0[idx], val)
def debug(self):
print(("layer0=", self.layer0))
print(("layer1=", self.layer1))
def __getitem__(self, item):
return self.layer1[item]
def __setitem__(self, key, value):
self.set_value(key, value)
from operator import itemgetter
N, M = list(map(int, input().split()))
LRC = [list(map(int, input().split())) for _ in range(M)]
LRC.sort(key=itemgetter(0))
idx_LRC = 0
q = []
inf = 10**18
seg = Rmq(N+1, inf=inf)
seg.set_value(1, 0)
for v in range(1, N + 1):
d = seg.get_min(v, N + 1)
while idx_LRC < M:
l, r, c = LRC[idx_LRC]
if l <= v:
seg.chmin(r, d+c)
idx_LRC += 1
else:
break
ans = seg[N]
print((ans if ans != inf else -1))
| 69 | 76 | 2,135 | 2,237 |
# 抽象化をやめる
class Rmq(object):
__slots__ = ["elem_size", "tree", "real_size"]
def __init__(self, a):
if hasattr(a, "__iter__"):
self.real_size = len(a)
self.elem_size = elem_size = 1 << (self.real_size - 1).bit_length()
self.tree = tree = [float("inf")] * (elem_size * 2)
tree[elem_size : elem_size + self.real_size] = a
for i in range(elem_size - 1, 0, -1):
tree[i] = min(tree[i << 1], tree[(i << 1) + 1])
elif isinstance(a, int):
self.real_size = a
self.elem_size = elem_size = 1 << (self.real_size - 1).bit_length()
self.tree = [float("inf")] * (elem_size * 2)
def get_value(self, x: int, y: int) -> int: # 半開区間
l, r = x + self.elem_size, y + self.elem_size
tree = self.tree
result = float("inf")
while l < r:
if l & 1:
result = min(tree[l], result)
l += 1
if r & 1:
r -= 1
result = min(tree[r], result)
l, r = l >> 1, r >> 1
return result
def set_value(self, i: int, value: int) -> None:
k = self.elem_size + i
tree = self.tree
tree[k] = value
while k > 1:
k >>= 1
tree[k] = min(tree[k << 1], tree[(k << 1) + 1])
def get_one_value(self, i):
return self.tree[i + self.elem_size]
def debug(self):
print((self.tree[self.elem_size : self.elem_size + self.real_size]))
from operator import itemgetter
N, M = list(map(int, input().split()))
LRC = [list(map(int, input().split())) for _ in range(M)]
LRC.sort(key=itemgetter(0))
idx_LRC = 0
q = []
seg = Rmq(N + 1)
seg.set_value(1, 0)
for v in range(1, N + 1):
d = seg.get_value(v, N + 1)
while idx_LRC < M:
l, r, c = LRC[idx_LRC]
if l <= v:
seg.set_value(r, min(seg.tree[r + seg.elem_size], d + c))
idx_LRC += 1
else:
break
ans = seg.tree[N + seg.elem_size]
print((ans if ans != float("inf") else -1))
|
# RMQ のパフォーマンステスト
class Rmq:
# 平方分割
# 値を変更すると元のリストの値も書き換わる
# 検証: http://judge.u-aizu.ac.jp/onlinejudge/review.jsp?rid=3990681
def __init__(self, a, sqrt_n=150, inf=(1 << 31) - 1):
self.sqrt_n = sqrt_n
if hasattr(a, "__iter__"):
from itertools import zip_longest
self.n = len(a)
self.layer0 = [
min(values)
for values in zip_longest(*[iter(a)] * sqrt_n, fillvalue=inf)
]
self.layer1 = a
elif isinstance(a, int):
self.n = a
self.layer0 = [inf] * ((a - 1) // sqrt_n + 1)
self.layer1 = [inf] * a
else:
raise TypeError
def get_min(self, l, r):
sqrt_n = self.sqrt_n
parent_l, parent_r = l // sqrt_n + 1, (r - 1) // sqrt_n
if parent_l < parent_r:
return min(
min(self.layer0[parent_l:parent_r]),
min(self.layer1[l : parent_l * sqrt_n]),
min(self.layer1[parent_r * sqrt_n : r]),
)
else:
return min(self.layer1[l:r])
def set_value(self, idx, val):
self.layer1[idx] = val
idx0 = idx // self.sqrt_n
idx1 = idx0 * self.sqrt_n
self.layer0[idx0] = min(self.layer1[idx1 : idx1 + self.sqrt_n])
def chmin(self, idx, val):
if self.layer1[idx] > val:
self.layer1[idx] = val
idx //= self.sqrt_n
self.layer0[idx] = min(self.layer0[idx], val)
def debug(self):
print(("layer0=", self.layer0))
print(("layer1=", self.layer1))
def __getitem__(self, item):
return self.layer1[item]
def __setitem__(self, key, value):
self.set_value(key, value)
from operator import itemgetter
N, M = list(map(int, input().split()))
LRC = [list(map(int, input().split())) for _ in range(M)]
LRC.sort(key=itemgetter(0))
idx_LRC = 0
q = []
inf = 10**18
seg = Rmq(N + 1, inf=inf)
seg.set_value(1, 0)
for v in range(1, N + 1):
d = seg.get_min(v, N + 1)
while idx_LRC < M:
l, r, c = LRC[idx_LRC]
if l <= v:
seg.chmin(r, d + c)
idx_LRC += 1
else:
break
ans = seg[N]
print((ans if ans != inf else -1))
| false | 9.210526 |
[
"-# 抽象化をやめる",
"-class Rmq(object):",
"- __slots__ = [\"elem_size\", \"tree\", \"real_size\"]",
"+# RMQ のパフォーマンステスト",
"+class Rmq:",
"+ # 平方分割",
"+ # 値を変更すると元のリストの値も書き換わる",
"+ # 検証: http://judge.u-aizu.ac.jp/onlinejudge/review.jsp?rid=3990681",
"+ def __init__(self, a, sqrt_n=150, inf=(1 << 31) - 1):",
"+ self.sqrt_n = sqrt_n",
"+ if hasattr(a, \"__iter__\"):",
"+ from itertools import zip_longest",
"- def __init__(self, a):",
"- if hasattr(a, \"__iter__\"):",
"- self.real_size = len(a)",
"- self.elem_size = elem_size = 1 << (self.real_size - 1).bit_length()",
"- self.tree = tree = [float(\"inf\")] * (elem_size * 2)",
"- tree[elem_size : elem_size + self.real_size] = a",
"- for i in range(elem_size - 1, 0, -1):",
"- tree[i] = min(tree[i << 1], tree[(i << 1) + 1])",
"+ self.n = len(a)",
"+ self.layer0 = [",
"+ min(values)",
"+ for values in zip_longest(*[iter(a)] * sqrt_n, fillvalue=inf)",
"+ ]",
"+ self.layer1 = a",
"- self.real_size = a",
"- self.elem_size = elem_size = 1 << (self.real_size - 1).bit_length()",
"- self.tree = [float(\"inf\")] * (elem_size * 2)",
"+ self.n = a",
"+ self.layer0 = [inf] * ((a - 1) // sqrt_n + 1)",
"+ self.layer1 = [inf] * a",
"+ else:",
"+ raise TypeError",
"- def get_value(self, x: int, y: int) -> int: # 半開区間",
"- l, r = x + self.elem_size, y + self.elem_size",
"- tree = self.tree",
"- result = float(\"inf\")",
"- while l < r:",
"- if l & 1:",
"- result = min(tree[l], result)",
"- l += 1",
"- if r & 1:",
"- r -= 1",
"- result = min(tree[r], result)",
"- l, r = l >> 1, r >> 1",
"- return result",
"+ def get_min(self, l, r):",
"+ sqrt_n = self.sqrt_n",
"+ parent_l, parent_r = l // sqrt_n + 1, (r - 1) // sqrt_n",
"+ if parent_l < parent_r:",
"+ return min(",
"+ min(self.layer0[parent_l:parent_r]),",
"+ min(self.layer1[l : parent_l * sqrt_n]),",
"+ min(self.layer1[parent_r * sqrt_n : r]),",
"+ )",
"+ else:",
"+ return min(self.layer1[l:r])",
"- def set_value(self, i: int, value: int) -> None:",
"- k = self.elem_size + i",
"- tree = self.tree",
"- tree[k] = value",
"- while k > 1:",
"- k >>= 1",
"- tree[k] = min(tree[k << 1], tree[(k << 1) + 1])",
"+ def set_value(self, idx, val):",
"+ self.layer1[idx] = val",
"+ idx0 = idx // self.sqrt_n",
"+ idx1 = idx0 * self.sqrt_n",
"+ self.layer0[idx0] = min(self.layer1[idx1 : idx1 + self.sqrt_n])",
"- def get_one_value(self, i):",
"- return self.tree[i + self.elem_size]",
"+ def chmin(self, idx, val):",
"+ if self.layer1[idx] > val:",
"+ self.layer1[idx] = val",
"+ idx //= self.sqrt_n",
"+ self.layer0[idx] = min(self.layer0[idx], val)",
"- print((self.tree[self.elem_size : self.elem_size + self.real_size]))",
"+ print((\"layer0=\", self.layer0))",
"+ print((\"layer1=\", self.layer1))",
"+",
"+ def __getitem__(self, item):",
"+ return self.layer1[item]",
"+",
"+ def __setitem__(self, key, value):",
"+ self.set_value(key, value)",
"-seg = Rmq(N + 1)",
"+inf = 10**18",
"+seg = Rmq(N + 1, inf=inf)",
"- d = seg.get_value(v, N + 1)",
"+ d = seg.get_min(v, N + 1)",
"- seg.set_value(r, min(seg.tree[r + seg.elem_size], d + c))",
"+ seg.chmin(r, d + c)",
"-ans = seg.tree[N + seg.elem_size]",
"-print((ans if ans != float(\"inf\") else -1))",
"+ans = seg[N]",
"+print((ans if ans != inf else -1))"
] | false | 0.039748 | 0.070302 | 0.56539 |
[
"s326073140",
"s926866848"
] |
u227020436
|
p02794
|
python
|
s387032109
|
s922726713
| 1,924 | 911 | 48,092 | 48,092 |
Accepted
|
Accepted
| 52.65 |
# F - Tree and Constraints
# Read input
n = int(eval(input()))
adj = {a: [] for a in range(1, n + 1)}
for i in range(n - 1):
a, b = list(map(int, input().split()))
adj[a].append(b)
adj[b].append(a)
m = int(eval(input()))
ranges = []
for i in range(m):
u, v = list(map(int, input().split()))
ranges.append((u, v))
# Subroutines
def normalized(u, v):
return (min(u, v), max(u, v))
def findpath(u, v, visited=None):
"""uからvへの経路 (辺の集合)"""
if visited is None:
visited = set()
if u == v:
return set()
if u in visited:
return None
visited.add(u)
for x in adj[u]:
p = findpath(x, v, visited)
if p is not None:
p.add(normalized(u, x))
return p
def powerset(seq, bag):
"""(seqの部分集合s, bag[e] for e in s の和集合)"""
if len(seq) <= 1:
yield ((seq[0],), bag[seq[0]])
yield ((), set())
else:
for s, b in powerset(seq[1:], bag):
yield ((seq[0],) + s, b | bag[seq[0]])
yield (s, b)
# Find paths
paths = {}
for u, v in ranges:
paths[(u, v)] = findpath(u, v)
# いずれかの区間をすべて白にする塗り方の個数
coloring = 0
for s, b in powerset(ranges, paths):
l = len(s)
if l <= 0:
continue
# b中の辺をすべて白にする塗り方の個数
c = 2 ** ((n - 1) - len(b))
# 包除原理
sign = -1 if l % 2 == 0 else 1
coloring += sign * c
# どの区間も黒を含む塗り方の個数
coloring = 2 ** (n - 1) - coloring
print(coloring)
|
# F - Tree and Constraints
# Read input
n = int(eval(input()))
adj = {a: [] for a in range(1, n + 1)}
for i in range(n - 1):
a, b = list(map(int, input().split()))
adj[a].append((b, i))
adj[b].append((a, i))
m = int(eval(input()))
ranges = [tuple(map(int, input().split())) for i in range(m)]
# Subroutines
def findpath(u, v, parent=None):
"""uからvへの経路 (辺の集合)"""
if u == v:
return set()
for x, i in adj[u]:
if x == parent:
continue
p = findpath(x, v, u)
if p is not None:
p.add(i) # id of edge
return p
return None
def powerset(seq, bag):
"""[(seqの部分集合s, bag[e] for e in s の和集合)]"""
if len(seq) <= 1:
yield ((seq[0],), bag[seq[0]])
yield ((), set())
else:
for s, b in powerset(seq[1:], bag):
yield ((seq[0],) + s, b | bag[seq[0]])
yield (s, b)
# Find paths
paths = [findpath(u, v) for u, v in ranges]
# いずれかの区間をすべて白にする塗り方の個数
white = 0
for s, b in powerset(list(range(m)), paths):
l = len(s)
if l <= 0:
continue
# b中の辺をすべて白にする塗り方の個数
w = 2 ** (n - 1 - len(b))
# 包除原理
sign = -1 if l % 2 == 0 else 1
white += sign * w
# どの区間も黒を含む塗り方の個数
coloring = 2 ** (n - 1) - white
print(coloring)
| 67 | 57 | 1,487 | 1,323 |
# F - Tree and Constraints
# Read input
n = int(eval(input()))
adj = {a: [] for a in range(1, n + 1)}
for i in range(n - 1):
a, b = list(map(int, input().split()))
adj[a].append(b)
adj[b].append(a)
m = int(eval(input()))
ranges = []
for i in range(m):
u, v = list(map(int, input().split()))
ranges.append((u, v))
# Subroutines
def normalized(u, v):
return (min(u, v), max(u, v))
def findpath(u, v, visited=None):
"""uからvへの経路 (辺の集合)"""
if visited is None:
visited = set()
if u == v:
return set()
if u in visited:
return None
visited.add(u)
for x in adj[u]:
p = findpath(x, v, visited)
if p is not None:
p.add(normalized(u, x))
return p
def powerset(seq, bag):
"""(seqの部分集合s, bag[e] for e in s の和集合)"""
if len(seq) <= 1:
yield ((seq[0],), bag[seq[0]])
yield ((), set())
else:
for s, b in powerset(seq[1:], bag):
yield ((seq[0],) + s, b | bag[seq[0]])
yield (s, b)
# Find paths
paths = {}
for u, v in ranges:
paths[(u, v)] = findpath(u, v)
# いずれかの区間をすべて白にする塗り方の個数
coloring = 0
for s, b in powerset(ranges, paths):
l = len(s)
if l <= 0:
continue
# b中の辺をすべて白にする塗り方の個数
c = 2 ** ((n - 1) - len(b))
# 包除原理
sign = -1 if l % 2 == 0 else 1
coloring += sign * c
# どの区間も黒を含む塗り方の個数
coloring = 2 ** (n - 1) - coloring
print(coloring)
|
# F - Tree and Constraints
# Read input
n = int(eval(input()))
adj = {a: [] for a in range(1, n + 1)}
for i in range(n - 1):
a, b = list(map(int, input().split()))
adj[a].append((b, i))
adj[b].append((a, i))
m = int(eval(input()))
ranges = [tuple(map(int, input().split())) for i in range(m)]
# Subroutines
def findpath(u, v, parent=None):
"""uからvへの経路 (辺の集合)"""
if u == v:
return set()
for x, i in adj[u]:
if x == parent:
continue
p = findpath(x, v, u)
if p is not None:
p.add(i) # id of edge
return p
return None
def powerset(seq, bag):
"""[(seqの部分集合s, bag[e] for e in s の和集合)]"""
if len(seq) <= 1:
yield ((seq[0],), bag[seq[0]])
yield ((), set())
else:
for s, b in powerset(seq[1:], bag):
yield ((seq[0],) + s, b | bag[seq[0]])
yield (s, b)
# Find paths
paths = [findpath(u, v) for u, v in ranges]
# いずれかの区間をすべて白にする塗り方の個数
white = 0
for s, b in powerset(list(range(m)), paths):
l = len(s)
if l <= 0:
continue
# b中の辺をすべて白にする塗り方の個数
w = 2 ** (n - 1 - len(b))
# 包除原理
sign = -1 if l % 2 == 0 else 1
white += sign * w
# どの区間も黒を含む塗り方の個数
coloring = 2 ** (n - 1) - white
print(coloring)
| false | 14.925373 |
[
"- adj[a].append(b)",
"- adj[b].append(a)",
"+ adj[a].append((b, i))",
"+ adj[b].append((a, i))",
"-ranges = []",
"-for i in range(m):",
"- u, v = list(map(int, input().split()))",
"- ranges.append((u, v))",
"+ranges = [tuple(map(int, input().split())) for i in range(m)]",
"-def normalized(u, v):",
"- return (min(u, v), max(u, v))",
"-",
"-",
"-def findpath(u, v, visited=None):",
"+def findpath(u, v, parent=None):",
"- if visited is None:",
"- visited = set()",
"- if u in visited:",
"- return None",
"- visited.add(u)",
"- for x in adj[u]:",
"- p = findpath(x, v, visited)",
"+ for x, i in adj[u]:",
"+ if x == parent:",
"+ continue",
"+ p = findpath(x, v, u)",
"- p.add(normalized(u, x))",
"+ p.add(i) # id of edge",
"+ return None",
"- \"\"\"(seqの部分集合s, bag[e] for e in s の和集合)\"\"\"",
"+ \"\"\"[(seqの部分集合s, bag[e] for e in s の和集合)]\"\"\"",
"-paths = {}",
"-for u, v in ranges:",
"- paths[(u, v)] = findpath(u, v)",
"+paths = [findpath(u, v) for u, v in ranges]",
"-coloring = 0",
"-for s, b in powerset(ranges, paths):",
"+white = 0",
"+for s, b in powerset(list(range(m)), paths):",
"- c = 2 ** ((n - 1) - len(b))",
"+ w = 2 ** (n - 1 - len(b))",
"- coloring += sign * c",
"+ white += sign * w",
"-coloring = 2 ** (n - 1) - coloring",
"+coloring = 2 ** (n - 1) - white"
] | false | 0.036176 | 0.062279 | 0.58087 |
[
"s387032109",
"s922726713"
] |
u692690314
|
p03160
|
python
|
s884802290
|
s982725358
| 206 | 145 | 13,928 | 13,980 |
Accepted
|
Accepted
| 29.61 |
N = int(eval(input()))
h = list(map(int, input().split()))
dp = [float('inf') for i in range(N)]
dp[0] = 0
for i in range(1, N):
if (dp[i] > dp[i-1] + abs(h[i] - h[i-1])):
dp[i] = dp[i-1] + abs(h[i] - h[i-1])
if i > 1:
if (dp[i] > dp[i-2] + abs(h[i] - h[i-2])):
dp[i] = dp[i-2] + abs(h[i] - h[i-2])
print((dp[-1]))
|
N = int(eval(input()))
h = list(map(int, input().split()))
cost = [0 for _ in range(len(h))]
for i in range(1, len(h)):
if i == 1:
cost[i] = abs(h[i] - h[i-1])
continue
cost[i] = min(cost[i-1] + abs(h[i] - h[i-1]), cost[i-2] + abs(h[i] - h[i-2]))
print((cost[-1]))
| 11 | 9 | 352 | 288 |
N = int(eval(input()))
h = list(map(int, input().split()))
dp = [float("inf") for i in range(N)]
dp[0] = 0
for i in range(1, N):
if dp[i] > dp[i - 1] + abs(h[i] - h[i - 1]):
dp[i] = dp[i - 1] + abs(h[i] - h[i - 1])
if i > 1:
if dp[i] > dp[i - 2] + abs(h[i] - h[i - 2]):
dp[i] = dp[i - 2] + abs(h[i] - h[i - 2])
print((dp[-1]))
|
N = int(eval(input()))
h = list(map(int, input().split()))
cost = [0 for _ in range(len(h))]
for i in range(1, len(h)):
if i == 1:
cost[i] = abs(h[i] - h[i - 1])
continue
cost[i] = min(
cost[i - 1] + abs(h[i] - h[i - 1]), cost[i - 2] + abs(h[i] - h[i - 2])
)
print((cost[-1]))
| false | 18.181818 |
[
"-dp = [float(\"inf\") for i in range(N)]",
"-dp[0] = 0",
"-for i in range(1, N):",
"- if dp[i] > dp[i - 1] + abs(h[i] - h[i - 1]):",
"- dp[i] = dp[i - 1] + abs(h[i] - h[i - 1])",
"- if i > 1:",
"- if dp[i] > dp[i - 2] + abs(h[i] - h[i - 2]):",
"- dp[i] = dp[i - 2] + abs(h[i] - h[i - 2])",
"-print((dp[-1]))",
"+cost = [0 for _ in range(len(h))]",
"+for i in range(1, len(h)):",
"+ if i == 1:",
"+ cost[i] = abs(h[i] - h[i - 1])",
"+ continue",
"+ cost[i] = min(",
"+ cost[i - 1] + abs(h[i] - h[i - 1]), cost[i - 2] + abs(h[i] - h[i - 2])",
"+ )",
"+print((cost[-1]))"
] | false | 0.047974 | 0.059412 | 0.807475 |
[
"s884802290",
"s982725358"
] |
u554269352
|
p03137
|
python
|
s968316093
|
s557657529
| 147 | 101 | 18,384 | 13,832 |
Accepted
|
Accepted
| 31.29 |
def main():
n, m = list(map(int, input().split()))
t = list(map(int, input().split()))
if n >= m:
return 0
t.sort()
x = [[t[i], t[i+1] - t[i]] for i in range(m-1)]
x.append([t[m-1], 0])
x.sort(key=lambda a: a[1], reverse=True)
sum_dis = t[m-1] - t[0]
skip_dis = sum([x[i][1] for i in range(n - 1)])
return sum_dis - skip_dis
print((main()))
|
def main():
N, M = list(map(int, input().split()))
t = [int(i) for i in input().split()]
t.sort()
if N >= M:
return 0
x = [j-i for i, j in zip(t, t[1:])]
x.sort(reverse=True)
return (t[-1] - t[0]) - sum([x[i] for i in range(N - 1)])
print((main()))
| 15 | 14 | 396 | 294 |
def main():
n, m = list(map(int, input().split()))
t = list(map(int, input().split()))
if n >= m:
return 0
t.sort()
x = [[t[i], t[i + 1] - t[i]] for i in range(m - 1)]
x.append([t[m - 1], 0])
x.sort(key=lambda a: a[1], reverse=True)
sum_dis = t[m - 1] - t[0]
skip_dis = sum([x[i][1] for i in range(n - 1)])
return sum_dis - skip_dis
print((main()))
|
def main():
N, M = list(map(int, input().split()))
t = [int(i) for i in input().split()]
t.sort()
if N >= M:
return 0
x = [j - i for i, j in zip(t, t[1:])]
x.sort(reverse=True)
return (t[-1] - t[0]) - sum([x[i] for i in range(N - 1)])
print((main()))
| false | 6.666667 |
[
"- n, m = list(map(int, input().split()))",
"- t = list(map(int, input().split()))",
"- if n >= m:",
"+ N, M = list(map(int, input().split()))",
"+ t = [int(i) for i in input().split()]",
"+ t.sort()",
"+ if N >= M:",
"- t.sort()",
"- x = [[t[i], t[i + 1] - t[i]] for i in range(m - 1)]",
"- x.append([t[m - 1], 0])",
"- x.sort(key=lambda a: a[1], reverse=True)",
"- sum_dis = t[m - 1] - t[0]",
"- skip_dis = sum([x[i][1] for i in range(n - 1)])",
"- return sum_dis - skip_dis",
"+ x = [j - i for i, j in zip(t, t[1:])]",
"+ x.sort(reverse=True)",
"+ return (t[-1] - t[0]) - sum([x[i] for i in range(N - 1)])"
] | false | 0.036434 | 0.080018 | 0.455322 |
[
"s968316093",
"s557657529"
] |
u418996726
|
p02257
|
python
|
s304228100
|
s924652274
| 450 | 360 | 5,612 | 5,624 |
Accepted
|
Accepted
| 20 |
class PrimeChecker:
def __init__(self):
self.primes = [2,3]
def isPrime(self, n):
if n in self.primes:
return True
else:
for i in self.primes:
if n % i == 0:
return False
i = 5
w = 2
while i * i <= n:
if n % i == 0:
return False
i += w
w = 6 - w
self.primes.append(n)
return True
primeChecker = PrimeChecker()
count = 0
N = int(eval(input()))
for _ in range(N):
if primeChecker.isPrime((int(eval(input())))):
count += 1
print(count)
|
class PrimeChecker:
def __init__(self):
self.primes = [2,3,5]
def isPrime(self, n):
if n in self.primes:
return True
elif n < self.primes[-1]:
return False
else:
for i in self.primes:
if n % i == 0:
return False
i = self.primes[-1]
w = 2 if i % 6 == 5 else 4
while i * i <= n:
if self.isPrime(i):
self.primes.append(i)
if n % i == 0:
return False
i += w
w = 6 - w
return True
primeChecker = PrimeChecker()
count = 0
N = int(eval(input()))
for _ in range(N):
if primeChecker.isPrime((int(eval(input())))):
count += 1
print(count)
| 35 | 37 | 668 | 821 |
class PrimeChecker:
def __init__(self):
self.primes = [2, 3]
def isPrime(self, n):
if n in self.primes:
return True
else:
for i in self.primes:
if n % i == 0:
return False
i = 5
w = 2
while i * i <= n:
if n % i == 0:
return False
i += w
w = 6 - w
self.primes.append(n)
return True
primeChecker = PrimeChecker()
count = 0
N = int(eval(input()))
for _ in range(N):
if primeChecker.isPrime((int(eval(input())))):
count += 1
print(count)
|
class PrimeChecker:
def __init__(self):
self.primes = [2, 3, 5]
def isPrime(self, n):
if n in self.primes:
return True
elif n < self.primes[-1]:
return False
else:
for i in self.primes:
if n % i == 0:
return False
i = self.primes[-1]
w = 2 if i % 6 == 5 else 4
while i * i <= n:
if self.isPrime(i):
self.primes.append(i)
if n % i == 0:
return False
i += w
w = 6 - w
return True
primeChecker = PrimeChecker()
count = 0
N = int(eval(input()))
for _ in range(N):
if primeChecker.isPrime((int(eval(input())))):
count += 1
print(count)
| false | 5.405405 |
[
"- self.primes = [2, 3]",
"+ self.primes = [2, 3, 5]",
"+ elif n < self.primes[-1]:",
"+ return False",
"- i = 5",
"- w = 2",
"+ i = self.primes[-1]",
"+ w = 2 if i % 6 == 5 else 4",
"- if n % i == 0:",
"- return False",
"+ if self.isPrime(i):",
"+ self.primes.append(i)",
"+ if n % i == 0:",
"+ return False",
"- self.primes.append(n)"
] | false | 0.044011 | 0.065374 | 0.673222 |
[
"s304228100",
"s924652274"
] |
u102461423
|
p03216
|
python
|
s365765332
|
s917108640
| 1,611 | 1,359 | 63,324 | 55,512 |
Accepted
|
Accepted
| 15.64 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
import numpy as np
N = int(readline())
S = np.frombuffer(readline().rstrip(),'S1')
Q = int(readline())
query = list(map(int,read().split()))
isD = S == b'D'
isM = S == b'M'
isC = S == b'C'
cumD = isD.cumsum(dtype=np.int64)
cumM = isM.cumsum(dtype=np.int64)
def F(K):
"""
・Cごとに数える。
・そのためには(i-K,i] 内のDMの個数を調べる（負インデックスには関係ない文字があると思っておく）
・区間内のDの個数、Mの個数が取得できれば、差分が取得できるので最後に累積和
"""
# (i-K,i]内のDの個数、Mの個数
D = cumD.copy(); D[K:] -= cumD[:-K]
M = cumM.copy(); M[K:] -= cumM[:-K]
# 最後がMのとき、Dの個数分増える
DM = isM * D
# 左端のDを捨てるとき、Mの個数分減る
DM[K:] -= isD[:-K] * M[K-1:-1]
np.cumsum(DM,out=DM)
# Cごとに集計
return (DM*isC).sum()
print(('\n'.join(str(F(K)) for K in query)))
|
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
import numpy as np
N = int(readline())
S = np.frombuffer(readline().rstrip(),'S1')
Q = int(readline())
query = list(map(int,read().split()))
isD = S == b'D'
isM = S == b'M'
isC = S == b'C'
cumD = isD.cumsum(dtype=np.int64)
cumM = isM.cumsum(dtype=np.int64)
def F(K):
"""
・Cごとに数える。
・そのためには(i-K,i] 内のDMの個数を調べる（負インデックスには関係ない文字があると思っておく）
・区間内のDの個数、Mの個数が取得できれば、差分が取得できるので最後に累積和
"""
# (i-K,i]内のDの個数、Mの個数
D = cumD.copy(); D[K:] -= cumD[:-K]
M = cumM.copy(); M[K:] -= cumM[:-K]
# 最後がMのとき、Dの個数分増える
DM = D; DM *= isM
# 左端のDを捨てるとき、Mの個数分減る
DM[K:] -= isD[:-K] * M[K-1:-1]
np.cumsum(DM,out=DM)
# Cごとに集計
return (DM*isC).sum()
print(('\n'.join(str(F(K)) for K in query)))
| 37 | 37 | 860 | 865 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
import numpy as np
N = int(readline())
S = np.frombuffer(readline().rstrip(), "S1")
Q = int(readline())
query = list(map(int, read().split()))
isD = S == b"D"
isM = S == b"M"
isC = S == b"C"
cumD = isD.cumsum(dtype=np.int64)
cumM = isM.cumsum(dtype=np.int64)
def F(K):
"""
・Cごとに数える。
・そのためには(i-K,i] 内のDMの個数を調べる（負インデックスには関係ない文字があると思っておく）
・区間内のDの個数、Mの個数が取得できれば、差分が取得できるので最後に累積和
"""
# (i-K,i]内のDの個数、Mの個数
D = cumD.copy()
D[K:] -= cumD[:-K]
M = cumM.copy()
M[K:] -= cumM[:-K]
# 最後がMのとき、Dの個数分増える
DM = isM * D
# 左端のDを捨てるとき、Mの個数分減る
DM[K:] -= isD[:-K] * M[K - 1 : -1]
np.cumsum(DM, out=DM)
# Cごとに集計
return (DM * isC).sum()
print(("\n".join(str(F(K)) for K in query)))
|
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
import numpy as np
N = int(readline())
S = np.frombuffer(readline().rstrip(), "S1")
Q = int(readline())
query = list(map(int, read().split()))
isD = S == b"D"
isM = S == b"M"
isC = S == b"C"
cumD = isD.cumsum(dtype=np.int64)
cumM = isM.cumsum(dtype=np.int64)
def F(K):
"""
・Cごとに数える。
・そのためには(i-K,i] 内のDMの個数を調べる（負インデックスには関係ない文字があると思っておく）
・区間内のDの個数、Mの個数が取得できれば、差分が取得できるので最後に累積和
"""
# (i-K,i]内のDの個数、Mの個数
D = cumD.copy()
D[K:] -= cumD[:-K]
M = cumM.copy()
M[K:] -= cumM[:-K]
# 最後がMのとき、Dの個数分増える
DM = D
DM *= isM
# 左端のDを捨てるとき、Mの個数分減る
DM[K:] -= isD[:-K] * M[K - 1 : -1]
np.cumsum(DM, out=DM)
# Cごとに集計
return (DM * isC).sum()
print(("\n".join(str(F(K)) for K in query)))
| false | 0 |
[
"- DM = isM * D",
"+ DM = D",
"+ DM *= isM"
] | false | 0.277532 | 0.447131 | 0.620696 |
[
"s365765332",
"s917108640"
] |
u077291787
|
p02579
|
python
|
s321106022
|
s222293757
| 451 | 239 | 220,204 | 96,708 |
Accepted
|
Accepted
| 47.01 |
# D - Wizard in Maze
import sys
from collections import deque
from typing import List, Tuple
class WarpableMaze:
__slots__ = ["height", "width", "road", "wall", "grid"]
def __init__(
self,
height: int,
width: int,
grid: List[str],
road: str = ".",
wall: str = "#",
) -> None:
# Values of start and goal must be 0-origin.
self.height = height + 4
self.width = width + 4
self.road = road
self.wall = wall
self.grid = self._flatten_grid(grid)
def _flatten_grid(self, grid: List[str]) -> str:
flat_grid = self.wall * self.width * 2
for row in grid:
flat_grid += self.wall * 2 + row + self.wall * 2
flat_grid += self.wall * self.width * 2
return flat_grid
def _flatten_dxy(self, x: int, y: int) -> int:
return self.width * x + y
def _flatten_coordinate(self, h: int, w: int) -> int:
return self._flatten_dxy(h + 2, w + 2)
def bfs(self, start_2d: Tuple[int, int], goal_2d: Tuple[int, int]) -> int:
start = self._flatten_coordinate(*start_2d)
goal = self._flatten_coordinate(*goal_2d)
w = self.width
flatten = lambda *dxy: tuple(self._flatten_dxy(*xy) for xy in dxy)
move_to_warp = {
-w: flatten((-2, -2), (-2, -1), (-2, 0), (-2, 1), (-1, -1)),
w: flatten((1, 1), (2, -1), (2, 0), (2, 1), (2, 2)),
-1: flatten((-1, -2), (0, -2), (1, -2), (1, -1), (2, -2)),
1: flatten((-1, 1), (-2, 2), (-1, 2), (0, 2), (1, 2)),
}
unsearched = 1 << 30
dist = [unsearched] * (self.height * self.width)
dist[start] = 0
queue = deque([start])
while queue:
x = queue.popleft()
cur_dist = dist[x]
if x == goal:
break
for move, warp in move_to_warp.items():
nx = x + move
if self.grid[nx] == self.road:
if dist[nx] > cur_dist:
dist[nx] = cur_dist
queue.appendleft(nx)
continue
for dx in warp:
nx = x + dx
if self.grid[nx] == self.wall:
continue
if dist[nx] > cur_dist + 1:
dist[nx] = cur_dist + 1
queue.append(nx)
return dist[goal] if dist[goal] != unsearched else -1
def debug(self):
print("<DEBUG>", file=sys.stderr)
for row in zip(*[iter(self.grid)] * self.width):
print(*row, file=sys.stderr)
def main():
H, W, CH, CW, DH, DW, *S = open(0).read().split()
maze = WarpableMaze(int(H), int(W), S)
start, goal = (int(CH) - 1, int(CW) - 1), (int(DH) - 1, int(DW) - 1)
print(maze.bfs(start, goal))
# maze.debug()
if __name__ == "__main__":
main()
|
# D - Wizard in Maze
import sys
from collections import deque
from typing import List, Tuple
class WarpableMaze:
__slots__ = ["height", "width", "road", "wall", "unsearched", "dist"]
def __init__(
self,
height: int,
width: int,
grid: List[bytes],
road: str = ".",
wall: str = "#",
) -> None:
self.height = height + 4
self.width = width + 4
self.road = road
self.wall = wall
self.unsearched = 1 << 30
self.dist = self._convert_grid_to_dist(grid)
def _flatten_dxy(self, x: int, y: int) -> int:
return self.width * x + y
def _flatten_coordinate(self, h: int, w: int) -> int:
return self._flatten_dxy(h + 2, w + 2)
def _convert_grid_to_dist(self, grid: List[bytes]) -> List[int]:
dist = [-1] * self.height * self.width
i = self.width * 2 + 1
for row in grid:
for c in row.decode():
i += 1
if c == self.road:
dist[i] = self.unsearched
i += 4
return dist
def bfs(self, start_2d: Tuple[int, int], goal_2d: Tuple[int, int]) -> int:
start = self._flatten_coordinate(*start_2d)
goal = self._flatten_coordinate(*goal_2d)
w = self.width
walk_to_warp = {
-w: (-2 * w - 2, -2 * w - 1, -2 * w, -2 * w + 1, -w - 1),
w: (w + 1, 2 * w - 1, 2 * w, 2 * w + 1, 2 * w + 2),
-1: (-w - 2, -2, w - 2, w - 1, 2 * w - 2),
1: (-w + 1, -2 * w + 2, -w + 2, 2, w + 2),
}
dist = self.dist[:]
dist[start] = 0
queue = deque([start])
while queue:
x = queue.popleft()
cur_dist = dist[x]
if x == goal:
break
for walk, warp in walk_to_warp.items():
nx = x + walk
if dist[nx] > cur_dist:
dist[nx] = cur_dist
queue.appendleft(nx)
continue
if dist[nx] >= 0:
continue
for dx in warp:
nx = x + dx
if dist[nx] > cur_dist + 1:
dist[nx] = cur_dist + 1
queue.append(nx)
return dist[goal] if dist[goal] != self.unsearched else -1
def debug(self):
print("<DEBUG>", file=sys.stderr)
for row in zip(*[iter(self.dist)] * self.width):
print(*row, file=sys.stderr)
def main():
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
H, W = map(int, readline().split())
CH, CW = map(int, readline().split())
DH, DW = map(int, readline().split())
(*S,) = read().split()
maze = WarpableMaze(H, W, S)
start, goal = (CH - 1, CW - 1), (DH - 1, DW - 1)
print(maze.bfs(start, goal))
# maze.debug()
if __name__ == "__main__":
main()
| 94 | 102 | 3,041 | 3,048 |
# D - Wizard in Maze
import sys
from collections import deque
from typing import List, Tuple
class WarpableMaze:
__slots__ = ["height", "width", "road", "wall", "grid"]
def __init__(
self,
height: int,
width: int,
grid: List[str],
road: str = ".",
wall: str = "#",
) -> None:
# Values of start and goal must be 0-origin.
self.height = height + 4
self.width = width + 4
self.road = road
self.wall = wall
self.grid = self._flatten_grid(grid)
def _flatten_grid(self, grid: List[str]) -> str:
flat_grid = self.wall * self.width * 2
for row in grid:
flat_grid += self.wall * 2 + row + self.wall * 2
flat_grid += self.wall * self.width * 2
return flat_grid
def _flatten_dxy(self, x: int, y: int) -> int:
return self.width * x + y
def _flatten_coordinate(self, h: int, w: int) -> int:
return self._flatten_dxy(h + 2, w + 2)
def bfs(self, start_2d: Tuple[int, int], goal_2d: Tuple[int, int]) -> int:
start = self._flatten_coordinate(*start_2d)
goal = self._flatten_coordinate(*goal_2d)
w = self.width
flatten = lambda *dxy: tuple(self._flatten_dxy(*xy) for xy in dxy)
move_to_warp = {
-w: flatten((-2, -2), (-2, -1), (-2, 0), (-2, 1), (-1, -1)),
w: flatten((1, 1), (2, -1), (2, 0), (2, 1), (2, 2)),
-1: flatten((-1, -2), (0, -2), (1, -2), (1, -1), (2, -2)),
1: flatten((-1, 1), (-2, 2), (-1, 2), (0, 2), (1, 2)),
}
unsearched = 1 << 30
dist = [unsearched] * (self.height * self.width)
dist[start] = 0
queue = deque([start])
while queue:
x = queue.popleft()
cur_dist = dist[x]
if x == goal:
break
for move, warp in move_to_warp.items():
nx = x + move
if self.grid[nx] == self.road:
if dist[nx] > cur_dist:
dist[nx] = cur_dist
queue.appendleft(nx)
continue
for dx in warp:
nx = x + dx
if self.grid[nx] == self.wall:
continue
if dist[nx] > cur_dist + 1:
dist[nx] = cur_dist + 1
queue.append(nx)
return dist[goal] if dist[goal] != unsearched else -1
def debug(self):
print("<DEBUG>", file=sys.stderr)
for row in zip(*[iter(self.grid)] * self.width):
print(*row, file=sys.stderr)
def main():
H, W, CH, CW, DH, DW, *S = open(0).read().split()
maze = WarpableMaze(int(H), int(W), S)
start, goal = (int(CH) - 1, int(CW) - 1), (int(DH) - 1, int(DW) - 1)
print(maze.bfs(start, goal))
# maze.debug()
if __name__ == "__main__":
main()
|
# D - Wizard in Maze
import sys
from collections import deque
from typing import List, Tuple
class WarpableMaze:
__slots__ = ["height", "width", "road", "wall", "unsearched", "dist"]
def __init__(
self,
height: int,
width: int,
grid: List[bytes],
road: str = ".",
wall: str = "#",
) -> None:
self.height = height + 4
self.width = width + 4
self.road = road
self.wall = wall
self.unsearched = 1 << 30
self.dist = self._convert_grid_to_dist(grid)
def _flatten_dxy(self, x: int, y: int) -> int:
return self.width * x + y
def _flatten_coordinate(self, h: int, w: int) -> int:
return self._flatten_dxy(h + 2, w + 2)
def _convert_grid_to_dist(self, grid: List[bytes]) -> List[int]:
dist = [-1] * self.height * self.width
i = self.width * 2 + 1
for row in grid:
for c in row.decode():
i += 1
if c == self.road:
dist[i] = self.unsearched
i += 4
return dist
def bfs(self, start_2d: Tuple[int, int], goal_2d: Tuple[int, int]) -> int:
start = self._flatten_coordinate(*start_2d)
goal = self._flatten_coordinate(*goal_2d)
w = self.width
walk_to_warp = {
-w: (-2 * w - 2, -2 * w - 1, -2 * w, -2 * w + 1, -w - 1),
w: (w + 1, 2 * w - 1, 2 * w, 2 * w + 1, 2 * w + 2),
-1: (-w - 2, -2, w - 2, w - 1, 2 * w - 2),
1: (-w + 1, -2 * w + 2, -w + 2, 2, w + 2),
}
dist = self.dist[:]
dist[start] = 0
queue = deque([start])
while queue:
x = queue.popleft()
cur_dist = dist[x]
if x == goal:
break
for walk, warp in walk_to_warp.items():
nx = x + walk
if dist[nx] > cur_dist:
dist[nx] = cur_dist
queue.appendleft(nx)
continue
if dist[nx] >= 0:
continue
for dx in warp:
nx = x + dx
if dist[nx] > cur_dist + 1:
dist[nx] = cur_dist + 1
queue.append(nx)
return dist[goal] if dist[goal] != self.unsearched else -1
def debug(self):
print("<DEBUG>", file=sys.stderr)
for row in zip(*[iter(self.dist)] * self.width):
print(*row, file=sys.stderr)
def main():
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
H, W = map(int, readline().split())
CH, CW = map(int, readline().split())
DH, DW = map(int, readline().split())
(*S,) = read().split()
maze = WarpableMaze(H, W, S)
start, goal = (CH - 1, CW - 1), (DH - 1, DW - 1)
print(maze.bfs(start, goal))
# maze.debug()
if __name__ == "__main__":
main()
| false | 7.843137 |
[
"- __slots__ = [\"height\", \"width\", \"road\", \"wall\", \"grid\"]",
"+ __slots__ = [\"height\", \"width\", \"road\", \"wall\", \"unsearched\", \"dist\"]",
"- grid: List[str],",
"+ grid: List[bytes],",
"- # Values of start and goal must be 0-origin.",
"- self.grid = self._flatten_grid(grid)",
"-",
"- def _flatten_grid(self, grid: List[str]) -> str:",
"- flat_grid = self.wall * self.width * 2",
"- for row in grid:",
"- flat_grid += self.wall * 2 + row + self.wall * 2",
"- flat_grid += self.wall * self.width * 2",
"- return flat_grid",
"+ self.unsearched = 1 << 30",
"+ self.dist = self._convert_grid_to_dist(grid)",
"+ def _convert_grid_to_dist(self, grid: List[bytes]) -> List[int]:",
"+ dist = [-1] * self.height * self.width",
"+ i = self.width * 2 + 1",
"+ for row in grid:",
"+ for c in row.decode():",
"+ i += 1",
"+ if c == self.road:",
"+ dist[i] = self.unsearched",
"+ i += 4",
"+ return dist",
"+",
"- flatten = lambda *dxy: tuple(self._flatten_dxy(*xy) for xy in dxy)",
"- move_to_warp = {",
"- -w: flatten((-2, -2), (-2, -1), (-2, 0), (-2, 1), (-1, -1)),",
"- w: flatten((1, 1), (2, -1), (2, 0), (2, 1), (2, 2)),",
"- -1: flatten((-1, -2), (0, -2), (1, -2), (1, -1), (2, -2)),",
"- 1: flatten((-1, 1), (-2, 2), (-1, 2), (0, 2), (1, 2)),",
"+ walk_to_warp = {",
"+ -w: (-2 * w - 2, -2 * w - 1, -2 * w, -2 * w + 1, -w - 1),",
"+ w: (w + 1, 2 * w - 1, 2 * w, 2 * w + 1, 2 * w + 2),",
"+ -1: (-w - 2, -2, w - 2, w - 1, 2 * w - 2),",
"+ 1: (-w + 1, -2 * w + 2, -w + 2, 2, w + 2),",
"- unsearched = 1 << 30",
"- dist = [unsearched] * (self.height * self.width)",
"+ dist = self.dist[:]",
"- for move, warp in move_to_warp.items():",
"- nx = x + move",
"- if self.grid[nx] == self.road:",
"- if dist[nx] > cur_dist:",
"- dist[nx] = cur_dist",
"- queue.appendleft(nx)",
"+ for walk, warp in walk_to_warp.items():",
"+ nx = x + walk",
"+ if dist[nx] > cur_dist:",
"+ dist[nx] = cur_dist",
"+ queue.appendleft(nx)",
"+ continue",
"+ if dist[nx] >= 0:",
"- if self.grid[nx] == self.wall:",
"- continue",
"- return dist[goal] if dist[goal] != unsearched else -1",
"+ return dist[goal] if dist[goal] != self.unsearched else -1",
"- for row in zip(*[iter(self.grid)] * self.width):",
"+ for row in zip(*[iter(self.dist)] * self.width):",
"- H, W, CH, CW, DH, DW, *S = open(0).read().split()",
"- maze = WarpableMaze(int(H), int(W), S)",
"- start, goal = (int(CH) - 1, int(CW) - 1), (int(DH) - 1, int(DW) - 1)",
"+ read = sys.stdin.buffer.read",
"+ readline = sys.stdin.buffer.readline",
"+ H, W = map(int, readline().split())",
"+ CH, CW = map(int, readline().split())",
"+ DH, DW = map(int, readline().split())",
"+ (*S,) = read().split()",
"+ maze = WarpableMaze(H, W, S)",
"+ start, goal = (CH - 1, CW - 1), (DH - 1, DW - 1)"
] | false | 0.132526 | 0.052836 | 2.508253 |
[
"s321106022",
"s222293757"
] |
u796942881
|
p03274
|
python
|
s935505597
|
s964035109
| 66 | 60 | 14,052 | 14,052 |
Accepted
|
Accepted
| 9.09 |
def main():
N, K, *xn = list(map(int, open(0).read().split()))
ans = int(1e9 + 7)
for xl, xr in zip(xn[:], xn[K - 1:]):
t = min(ans, xr - xl + min(abs(xr), abs(xl)))
ans = t if t < ans else ans
print(ans)
return
main()
|
def main():
N, K, *xn = list(map(int, open(0).read().split()))
ans = int(1e9 + 7)
for xl, xr in zip(xn, xn[K - 1:]):
t = xr - xl + min(abs(xl), abs(xr))
ans = t if t < ans else ans
print(ans)
return
main()
| 11 | 11 | 261 | 248 |
def main():
N, K, *xn = list(map(int, open(0).read().split()))
ans = int(1e9 + 7)
for xl, xr in zip(xn[:], xn[K - 1 :]):
t = min(ans, xr - xl + min(abs(xr), abs(xl)))
ans = t if t < ans else ans
print(ans)
return
main()
|
def main():
N, K, *xn = list(map(int, open(0).read().split()))
ans = int(1e9 + 7)
for xl, xr in zip(xn, xn[K - 1 :]):
t = xr - xl + min(abs(xl), abs(xr))
ans = t if t < ans else ans
print(ans)
return
main()
| false | 0 |
[
"- for xl, xr in zip(xn[:], xn[K - 1 :]):",
"- t = min(ans, xr - xl + min(abs(xr), abs(xl)))",
"+ for xl, xr in zip(xn, xn[K - 1 :]):",
"+ t = xr - xl + min(abs(xl), abs(xr))"
] | false | 0.113809 | 0.047546 | 2.393647 |
[
"s935505597",
"s964035109"
] |
u363369454
|
p02875
|
python
|
s193685752
|
s046645163
| 1,957 | 1,790 | 226,484 | 220,836 |
Accepted
|
Accepted
| 8.53 |
n=int(eval(input()));l=[0,1];a=0;b=c=1;p=998244353
for i in range(2,n):l+=[l[p%i]*(p-p//i)%p]
for i in range(n,n//2,-1):a+=b*c%p;b+=b%p;c=c*i*l[n+1-i]%p
print(((pow(3,n,p)-2*a)%p))
|
n=int(eval(input()));l=[0,1];a=0;b=c=1;p=998244353
for i in range(2,n):l+=[l[p%i]*(p-p//i)%p]
for i in range(n,n//2,-1):a+=b*c;b+=b%p;c=c*i*l[n+1-i]%p
print(((pow(3,n,p)-2*a)%p))
| 4 | 4 | 175 | 173 |
n = int(eval(input()))
l = [0, 1]
a = 0
b = c = 1
p = 998244353
for i in range(2, n):
l += [l[p % i] * (p - p // i) % p]
for i in range(n, n // 2, -1):
a += b * c % p
b += b % p
c = c * i * l[n + 1 - i] % p
print(((pow(3, n, p) - 2 * a) % p))
|
n = int(eval(input()))
l = [0, 1]
a = 0
b = c = 1
p = 998244353
for i in range(2, n):
l += [l[p % i] * (p - p // i) % p]
for i in range(n, n // 2, -1):
a += b * c
b += b % p
c = c * i * l[n + 1 - i] % p
print(((pow(3, n, p) - 2 * a) % p))
| false | 0 |
[
"- a += b * c % p",
"+ a += b * c"
] | false | 0.305941 | 0.460606 | 0.664214 |
[
"s193685752",
"s046645163"
] |
u691018832
|
p03200
|
python
|
s045997950
|
s952918445
| 122 | 75 | 3,500 | 3,376 |
Accepted
|
Accepted
| 38.52 |
s = eval(input())
ans = 0
ss = s.count('B')
sss = len(s)
index = -1
sum_s = 0
for i in range(ss):
index = s.find('B', index+1)
ans += sss-index-1
sum_s += i
ans -= sum_s
print(ans)
|
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
s = read().rstrip().decode()
cnt = 0
ans = 0
for i, ss in enumerate(s):
if ss == 'W':
ans += i - cnt
cnt += 1
print(ans)
| 14 | 14 | 205 | 302 |
s = eval(input())
ans = 0
ss = s.count("B")
sss = len(s)
index = -1
sum_s = 0
for i in range(ss):
index = s.find("B", index + 1)
ans += sss - index - 1
sum_s += i
ans -= sum_s
print(ans)
|
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10**7)
s = read().rstrip().decode()
cnt = 0
ans = 0
for i, ss in enumerate(s):
if ss == "W":
ans += i - cnt
cnt += 1
print(ans)
| false | 0 |
[
"-s = eval(input())",
"+import sys",
"+",
"+read = sys.stdin.buffer.read",
"+readline = sys.stdin.buffer.readline",
"+readlines = sys.stdin.buffer.readlines",
"+sys.setrecursionlimit(10**7)",
"+s = read().rstrip().decode()",
"+cnt = 0",
"-ss = s.count(\"B\")",
"-sss = len(s)",
"-index = -1",
"-sum_s = 0",
"-for i in range(ss):",
"- index = s.find(\"B\", index + 1)",
"- ans += sss - index - 1",
"- sum_s += i",
"-ans -= sum_s",
"+for i, ss in enumerate(s):",
"+ if ss == \"W\":",
"+ ans += i - cnt",
"+ cnt += 1"
] | false | 0.007036 | 0.033353 | 0.210956 |
[
"s045997950",
"s952918445"
] |
u680851063
|
p02708
|
python
|
s631321507
|
s871017897
| 325 | 274 | 36,456 | 36,264 |
Accepted
|
Accepted
| 15.69 |
import numpy as np
n, k = list(map(int, input().split()))
#print(n,k)
ary = np.array([i for i in range(n+1)])
cum = np.cumsum(ary)
#print(cum)
ans = 0
for j in range(k,n+1):
ans += (cum[-1] - cum[-j-1]) - cum[j-1] + 1
else:
ans += 1
ans %= 10**9+7
print(ans)
|
import numpy as np
n, k = list(map(int, input().split()))
ary = np.array([i for i in range(n+1)])
#print(ary)
def lr(l,r): # 等差数列の'l'から'r'の和_mean*number
return (l+r)*(r-l+1)//2
ans = 0
for j in range(k,n+1):
l = lr(0, j-1)
r = lr(n+1-j, n)
ans += r-l+1
ans += 1
ans %= 10**9+7
print(ans)
| 17 | 20 | 288 | 327 |
import numpy as np
n, k = list(map(int, input().split()))
# print(n,k)
ary = np.array([i for i in range(n + 1)])
cum = np.cumsum(ary)
# print(cum)
ans = 0
for j in range(k, n + 1):
ans += (cum[-1] - cum[-j - 1]) - cum[j - 1] + 1
else:
ans += 1
ans %= 10**9 + 7
print(ans)
|
import numpy as np
n, k = list(map(int, input().split()))
ary = np.array([i for i in range(n + 1)])
# print(ary)
def lr(l, r): # 等差数列の'l'から'r'の和_mean*number
return (l + r) * (r - l + 1) // 2
ans = 0
for j in range(k, n + 1):
l = lr(0, j - 1)
r = lr(n + 1 - j, n)
ans += r - l + 1
ans += 1
ans %= 10**9 + 7
print(ans)
| false | 15 |
[
"-# print(n,k)",
"-cum = np.cumsum(ary)",
"-# print(cum)",
"+# print(ary)",
"+def lr(l, r): # 等差数列の'l'から'r'の和_mean*number",
"+ return (l + r) * (r - l + 1) // 2",
"+",
"+",
"- ans += (cum[-1] - cum[-j - 1]) - cum[j - 1] + 1",
"-else:",
"- ans += 1",
"- ans %= 10**9 + 7",
"+ l = lr(0, j - 1)",
"+ r = lr(n + 1 - j, n)",
"+ ans += r - l + 1",
"+ans += 1",
"+ans %= 10**9 + 7"
] | false | 0.65986 | 0.60881 | 1.083853 |
[
"s631321507",
"s871017897"
] |
u347640436
|
p03599
|
python
|
s549477003
|
s361264585
| 152 | 83 | 3,188 | 3,316 |
Accepted
|
Accepted
| 45.39 |
A, B, C, D, E, F = list(map(int, input().split()))
w = set()
for i in range(F // (100 * A) + 1):
t = F - 100 * i
for j in range(t // (100 * B) + 1):
a = (A * i + B * j) * 100
w.add(a)
w.remove(0)
s = set()
t = E * F // 100
for i in range(t // C + 1):
for j in range(t // D + 1):
b = C * i + D * j
if b < t:
s.add(b)
best_concentration = -1
best_a = -1
best_b = -1
for a in w:
for b in sorted(s):
if a + b > F:
break
if b > E * a // 100:
break
concentration = 100 * b / (a + b)
if concentration > best_concentration:
best_concentration = concentration
best_a = a
best_b = b
print((best_a + best_b, best_b))
|
A, B, C, D, E, F = list(map(int, input().split()))
w = set()
for i in range(F // (100 * A) + 1):
t = F - 100 * A * i
for j in range(t // (100 * B) + 1):
a = (A * i + B * j) * 100
w.add(a)
w.remove(0)
s = set()
t = E * F // 100
for i in range(t // C + 1):
u = t - C * i
for j in range(u // D + 1):
b = C * i + D * j
s.add(b)
best_concentration = -1
best_a = -1
best_b = -1
for a in w:
for b in sorted(s):
if a + b > F:
break
if b > E * a // 100:
break
concentration = 100 * b / (a + b)
if concentration > best_concentration:
best_concentration = concentration
best_a = a
best_b = b
print((best_a + best_b, best_b))
| 33 | 33 | 785 | 785 |
A, B, C, D, E, F = list(map(int, input().split()))
w = set()
for i in range(F // (100 * A) + 1):
t = F - 100 * i
for j in range(t // (100 * B) + 1):
a = (A * i + B * j) * 100
w.add(a)
w.remove(0)
s = set()
t = E * F // 100
for i in range(t // C + 1):
for j in range(t // D + 1):
b = C * i + D * j
if b < t:
s.add(b)
best_concentration = -1
best_a = -1
best_b = -1
for a in w:
for b in sorted(s):
if a + b > F:
break
if b > E * a // 100:
break
concentration = 100 * b / (a + b)
if concentration > best_concentration:
best_concentration = concentration
best_a = a
best_b = b
print((best_a + best_b, best_b))
|
A, B, C, D, E, F = list(map(int, input().split()))
w = set()
for i in range(F // (100 * A) + 1):
t = F - 100 * A * i
for j in range(t // (100 * B) + 1):
a = (A * i + B * j) * 100
w.add(a)
w.remove(0)
s = set()
t = E * F // 100
for i in range(t // C + 1):
u = t - C * i
for j in range(u // D + 1):
b = C * i + D * j
s.add(b)
best_concentration = -1
best_a = -1
best_b = -1
for a in w:
for b in sorted(s):
if a + b > F:
break
if b > E * a // 100:
break
concentration = 100 * b / (a + b)
if concentration > best_concentration:
best_concentration = concentration
best_a = a
best_b = b
print((best_a + best_b, best_b))
| false | 0 |
[
"- t = F - 100 * i",
"+ t = F - 100 * A * i",
"- for j in range(t // D + 1):",
"+ u = t - C * i",
"+ for j in range(u // D + 1):",
"- if b < t:",
"- s.add(b)",
"+ s.add(b)"
] | false | 0.127919 | 0.050276 | 2.544358 |
[
"s549477003",
"s361264585"
] |
u360061665
|
p03478
|
python
|
s181986535
|
s849653020
| 46 | 37 | 2,940 | 3,060 |
Accepted
|
Accepted
| 19.57 |
N, A, B = list(map(int, input().split(" ")))
ans = 0
for i in range(N+1):
wa = 0
for k in range(len(str(i))):
wa += int(str(i)[k])
if A <= wa <= B:
ans += i
print(ans)
|
n, a, b = list(map(int, input().split()))
ans = 0
for i in range(n+1):
if a <= sum(list(map(int, list(str(i))))) <= b:
ans += i
print(ans)
| 12 | 6 | 204 | 149 |
N, A, B = list(map(int, input().split(" ")))
ans = 0
for i in range(N + 1):
wa = 0
for k in range(len(str(i))):
wa += int(str(i)[k])
if A <= wa <= B:
ans += i
print(ans)
|
n, a, b = list(map(int, input().split()))
ans = 0
for i in range(n + 1):
if a <= sum(list(map(int, list(str(i))))) <= b:
ans += i
print(ans)
| false | 50 |
[
"-N, A, B = list(map(int, input().split(\" \")))",
"+n, a, b = list(map(int, input().split()))",
"-for i in range(N + 1):",
"- wa = 0",
"- for k in range(len(str(i))):",
"- wa += int(str(i)[k])",
"- if A <= wa <= B:",
"+for i in range(n + 1):",
"+ if a <= sum(list(map(int, list(str(i))))) <= b:"
] | false | 0.038155 | 0.03747 | 1.018279 |
[
"s181986535",
"s849653020"
] |
u077291787
|
p03608
|
python
|
s667317308
|
s406926054
| 1,185 | 341 | 13,292 | 9,828 |
Accepted
|
Accepted
| 71.22 |
# ABC073D - joisino's travel
from heapq import heapify, heappop, heappush
from itertools import permutations
def dijkstra(G: "Array[Array[int]]", size: int, start: int) -> list:
dist = [float("inf")] * size
queue = [(start, 0)]
heapify(queue)
while queue:
v, cost = heappop(queue)
if cost > dist[v]:
continue
dist[v] = cost
for u, next_cost in G[v]:
if cost + next_cost < dist[u]:
heappush(queue, (u, cost + next_cost))
return dist
def main():
global G, N
N, M, R, *RABC = list(map(int, open(0).read().split()))
visit, ABC = RABC[:R], RABC[R:]
G = [[] for _ in range(N + 1)]
for v, u, c in zip(*[iter(ABC)] * 3):
G[v].append((u, c)), G[u].append((v, c))
dist = {v: dijkstra(G, N + 1, v) for v in visit}
ans = float("inf")
for perm in permutations(visit):
cur = sum(dist[v][u] for v, u in zip(perm, perm[1:]))
ans = min(ans, cur)
print(ans)
if __name__ == "__main__":
main()
|
# ABC073D - joisino's travel
from heapq import heapify, heappop, heappush
from itertools import permutations
def dijkstra(G: "Array[Array[int]]", size: int, start: int) -> list:
dist = [float("inf")] * size
queue = [(0, start)]
heapify(queue)
while queue:
cost, v = heappop(queue)
if cost > dist[v]:
continue
dist[v] = cost
for u, next_cost in G[v]:
if cost + next_cost < dist[u]:
heappush(queue, (cost + next_cost, u))
return dist
def main():
global G, N
N, M, R, *RABC = list(map(int, open(0).read().split()))
visit, ABC = RABC[:R], RABC[R:]
G = [[] for _ in range(N + 1)]
for v, u, c in zip(*[iter(ABC)] * 3):
G[v].append((u, c)), G[u].append((v, c))
dist = {v: dijkstra(G, N + 1, v) for v in visit}
ans = float("inf")
for perm in permutations(visit):
cur = sum(dist[v][u] for v, u in zip(perm, perm[1:]))
ans = min(ans, cur)
print(ans)
if __name__ == "__main__":
main()
| 37 | 37 | 1,065 | 1,065 |
# ABC073D - joisino's travel
from heapq import heapify, heappop, heappush
from itertools import permutations
def dijkstra(G: "Array[Array[int]]", size: int, start: int) -> list:
dist = [float("inf")] * size
queue = [(start, 0)]
heapify(queue)
while queue:
v, cost = heappop(queue)
if cost > dist[v]:
continue
dist[v] = cost
for u, next_cost in G[v]:
if cost + next_cost < dist[u]:
heappush(queue, (u, cost + next_cost))
return dist
def main():
global G, N
N, M, R, *RABC = list(map(int, open(0).read().split()))
visit, ABC = RABC[:R], RABC[R:]
G = [[] for _ in range(N + 1)]
for v, u, c in zip(*[iter(ABC)] * 3):
G[v].append((u, c)), G[u].append((v, c))
dist = {v: dijkstra(G, N + 1, v) for v in visit}
ans = float("inf")
for perm in permutations(visit):
cur = sum(dist[v][u] for v, u in zip(perm, perm[1:]))
ans = min(ans, cur)
print(ans)
if __name__ == "__main__":
main()
|
# ABC073D - joisino's travel
from heapq import heapify, heappop, heappush
from itertools import permutations
def dijkstra(G: "Array[Array[int]]", size: int, start: int) -> list:
dist = [float("inf")] * size
queue = [(0, start)]
heapify(queue)
while queue:
cost, v = heappop(queue)
if cost > dist[v]:
continue
dist[v] = cost
for u, next_cost in G[v]:
if cost + next_cost < dist[u]:
heappush(queue, (cost + next_cost, u))
return dist
def main():
global G, N
N, M, R, *RABC = list(map(int, open(0).read().split()))
visit, ABC = RABC[:R], RABC[R:]
G = [[] for _ in range(N + 1)]
for v, u, c in zip(*[iter(ABC)] * 3):
G[v].append((u, c)), G[u].append((v, c))
dist = {v: dijkstra(G, N + 1, v) for v in visit}
ans = float("inf")
for perm in permutations(visit):
cur = sum(dist[v][u] for v, u in zip(perm, perm[1:]))
ans = min(ans, cur)
print(ans)
if __name__ == "__main__":
main()
| false | 0 |
[
"- queue = [(start, 0)]",
"+ queue = [(0, start)]",
"- v, cost = heappop(queue)",
"+ cost, v = heappop(queue)",
"- heappush(queue, (u, cost + next_cost))",
"+ heappush(queue, (cost + next_cost, u))"
] | false | 0.045252 | 0.044792 | 1.010277 |
[
"s667317308",
"s406926054"
] |
u621100542
|
p03042
|
python
|
s379296030
|
s125623983
| 179 | 163 | 38,388 | 38,256 |
Accepted
|
Accepted
| 8.94 |
S = eval(input())
A = int(S[0:2])
B = int(S[2:])
if A <= 12 and B <= 12 and A > 0 and B > 0:
print("AMBIGUOUS")
elif (A > 12 or A == 0) and B <= 12 and B > 0:
print("YYMM")
elif (B > 12 or B == 0) and A <= 12 and A > 0:
print("MMYY")
else:
print("NA")
|
# coding: utf-8
# Your code here!
S = eval(input())
A = int(S[0:2])
B = int(S[2:])
f1,f2 = False,False
if A > 0 and A <= 12:
f1 = True
if B > 0 and B <= 12:
f2 = True
if f1 and f2:
print("AMBIGUOUS")
elif f1:
print("MMYY")
elif f2:
print("YYMM")
else:
print("NA")
| 13 | 21 | 275 | 304 |
S = eval(input())
A = int(S[0:2])
B = int(S[2:])
if A <= 12 and B <= 12 and A > 0 and B > 0:
print("AMBIGUOUS")
elif (A > 12 or A == 0) and B <= 12 and B > 0:
print("YYMM")
elif (B > 12 or B == 0) and A <= 12 and A > 0:
print("MMYY")
else:
print("NA")
|
# coding: utf-8
# Your code here!
S = eval(input())
A = int(S[0:2])
B = int(S[2:])
f1, f2 = False, False
if A > 0 and A <= 12:
f1 = True
if B > 0 and B <= 12:
f2 = True
if f1 and f2:
print("AMBIGUOUS")
elif f1:
print("MMYY")
elif f2:
print("YYMM")
else:
print("NA")
| false | 38.095238 |
[
"+# coding: utf-8",
"+# Your code here!",
"-if A <= 12 and B <= 12 and A > 0 and B > 0:",
"+f1, f2 = False, False",
"+if A > 0 and A <= 12:",
"+ f1 = True",
"+if B > 0 and B <= 12:",
"+ f2 = True",
"+if f1 and f2:",
"-elif (A > 12 or A == 0) and B <= 12 and B > 0:",
"+elif f1:",
"+ print(\"MMYY\")",
"+elif f2:",
"-elif (B > 12 or B == 0) and A <= 12 and A > 0:",
"- print(\"MMYY\")"
] | false | 0.043383 | 0.04633 | 0.936375 |
[
"s379296030",
"s125623983"
] |
u871841829
|
p02684
|
python
|
s378267526
|
s125473995
| 179 | 133 | 32,268 | 32,368 |
Accepted
|
Accepted
| 25.7 |
import sys
n, k = list(map(int, input().split()))
ara = [0]
ara += list(map(int, input().split()))
now = 1
vis = []
taken = [0]*(n+1)
while taken[now] == 0:
vis.append(now)
taken[now] = 1
now = ara[now]
cycleLen = len(vis) - vis.index(now)
if k < vis.index(now):
print((vis[k]))
sys.exit()
k -= vis.index(now)
k %= cycleLen
print((vis[k + vis.index(now)]))
|
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
# mp = dict()
# for ix in range(N):
# mp[ix+1] = A[ix]
hist = []
exists = [0] * (N+1)
cur = 1
cnt = 0
# ここがおかしい?
# while True:
# cur = mp[cur]
# cnt += 1
# # K -= 1
# if exists[cur] != 0:
# break
# else:
# exists[cur] = 1
# hist.append(cur)
A = [0] + A
# print(A)
while exists[cur] == 0:
hist.append(cur)
exists[cur] = 1
cur = A[cur]
cycle_sp = cur
# cycle_l = 0
cycle_sp_ix = hist.index(cycle_sp)
import sys
if K < cycle_sp_ix:
print((hist[K]))
sys.exit()
cycle_l = len(hist) - cycle_sp_ix
# while True:
# cur = mp[cur]
# cycle_l += 1
# if cur == cycle_sp:
# break
rest = (K-cycle_sp_ix) % cycle_l
# print("cnt:", cnt)
# print("K:", K)
# print("cycle_l:", cycle_l)
# print("rest:", rest)
print((hist[rest + cycle_sp_ix]))
# while rest != 0:
# cur = mp[cur]
# rest -= 1
# print(cur)
"""
# hist = [1]
hist = {1: 0}
while True:
hk = hist.keys()[-1]
if not mp[hk] in hist.keys():
# hist.append(mp[hist[-1]])
hist[mp[hk]] = 0
else:
# found
cstart = hist.index(mp[hk])
cend = len(hist)
cycle_l = cend - cstart
# print("hist:", hist)
# print("cstart:", cstart)
# print("cend:", cend)
# print("cycle_l:", cycle_l)
ans_i = (K - cstart) % cycle_l
# print("ans_i:", ans_i)
ans = hist[cstart + ans_i]
print(ans)
break
"""
| 25 | 93 | 397 | 1,617 |
import sys
n, k = list(map(int, input().split()))
ara = [0]
ara += list(map(int, input().split()))
now = 1
vis = []
taken = [0] * (n + 1)
while taken[now] == 0:
vis.append(now)
taken[now] = 1
now = ara[now]
cycleLen = len(vis) - vis.index(now)
if k < vis.index(now):
print((vis[k]))
sys.exit()
k -= vis.index(now)
k %= cycleLen
print((vis[k + vis.index(now)]))
|
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
# mp = dict()
# for ix in range(N):
# mp[ix+1] = A[ix]
hist = []
exists = [0] * (N + 1)
cur = 1
cnt = 0
# ここがおかしい?
# while True:
# cur = mp[cur]
# cnt += 1
# # K -= 1
# if exists[cur] != 0:
# break
# else:
# exists[cur] = 1
# hist.append(cur)
A = [0] + A
# print(A)
while exists[cur] == 0:
hist.append(cur)
exists[cur] = 1
cur = A[cur]
cycle_sp = cur
# cycle_l = 0
cycle_sp_ix = hist.index(cycle_sp)
import sys
if K < cycle_sp_ix:
print((hist[K]))
sys.exit()
cycle_l = len(hist) - cycle_sp_ix
# while True:
# cur = mp[cur]
# cycle_l += 1
# if cur == cycle_sp:
# break
rest = (K - cycle_sp_ix) % cycle_l
# print("cnt:", cnt)
# print("K:", K)
# print("cycle_l:", cycle_l)
# print("rest:", rest)
print((hist[rest + cycle_sp_ix]))
# while rest != 0:
# cur = mp[cur]
# rest -= 1
# print(cur)
"""
# hist = [1]
hist = {1: 0}
while True:
hk = hist.keys()[-1]
if not mp[hk] in hist.keys():
# hist.append(mp[hist[-1]])
hist[mp[hk]] = 0
else:
# found
cstart = hist.index(mp[hk])
cend = len(hist)
cycle_l = cend - cstart
# print("hist:", hist)
# print("cstart:", cstart)
# print("cend:", cend)
# print("cycle_l:", cycle_l)
ans_i = (K - cstart) % cycle_l
# print("ans_i:", ans_i)
ans = hist[cstart + ans_i]
print(ans)
break
"""
| false | 73.11828 |
[
"+N, K = list(map(int, input().split()))",
"+A = list(map(int, input().split()))",
"+# mp = dict()",
"+# for ix in range(N):",
"+# mp[ix+1] = A[ix]",
"+hist = []",
"+exists = [0] * (N + 1)",
"+cur = 1",
"+cnt = 0",
"+# ここがおかしい?",
"+# while True:",
"+# cur = mp[cur]",
"+# cnt += 1",
"+# # K -= 1",
"+# if exists[cur] != 0:",
"+# break",
"+# else:",
"+# exists[cur] = 1",
"+# hist.append(cur)",
"+A = [0] + A",
"+# print(A)",
"+while exists[cur] == 0:",
"+ hist.append(cur)",
"+ exists[cur] = 1",
"+ cur = A[cur]",
"+cycle_sp = cur",
"+# cycle_l = 0",
"+cycle_sp_ix = hist.index(cycle_sp)",
"-n, k = list(map(int, input().split()))",
"-ara = [0]",
"-ara += list(map(int, input().split()))",
"-now = 1",
"-vis = []",
"-taken = [0] * (n + 1)",
"-while taken[now] == 0:",
"- vis.append(now)",
"- taken[now] = 1",
"- now = ara[now]",
"-cycleLen = len(vis) - vis.index(now)",
"-if k < vis.index(now):",
"- print((vis[k]))",
"+if K < cycle_sp_ix:",
"+ print((hist[K]))",
"-k -= vis.index(now)",
"-k %= cycleLen",
"-print((vis[k + vis.index(now)]))",
"+cycle_l = len(hist) - cycle_sp_ix",
"+# while True:",
"+# cur = mp[cur]",
"+# cycle_l += 1",
"+# if cur == cycle_sp:",
"+# break",
"+rest = (K - cycle_sp_ix) % cycle_l",
"+# print(\"cnt:\", cnt)",
"+# print(\"K:\", K)",
"+# print(\"cycle_l:\", cycle_l)",
"+# print(\"rest:\", rest)",
"+print((hist[rest + cycle_sp_ix]))",
"+# while rest != 0:",
"+# cur = mp[cur]",
"+# rest -= 1",
"+# print(cur)",
"+\"\"\"",
"+# hist = [1]",
"+hist = {1: 0}",
"+while True:",
"+ hk = hist.keys()[-1]",
"+ if not mp[hk] in hist.keys():",
"+ # hist.append(mp[hist[-1]])",
"+ hist[mp[hk]] = 0",
"+ else:",
"+ # found",
"+ cstart = hist.index(mp[hk])",
"+ cend = len(hist)",
"+ cycle_l = cend - cstart",
"+ # print(\"hist:\", hist)",
"+ # print(\"cstart:\", cstart)",
"+ # print(\"cend:\", cend)",
"+ # print(\"cycle_l:\", cycle_l)",
"+ ans_i = (K - cstart) % cycle_l",
"+ # print(\"ans_i:\", ans_i)",
"+ ans = hist[cstart + ans_i]",
"+ print(ans)",
"+ break",
"+\"\"\""
] | false | 0.185463 | 0.064138 | 2.891633 |
[
"s378267526",
"s125473995"
] |
u964299793
|
p02762
|
python
|
s093498133
|
s418614808
| 1,031 | 698 | 18,712 | 18,712 |
Accepted
|
Accepted
| 32.3 |
import sys
#input=sys.stdin.readline
class UnionFind():
def __init__(self,n):
self.n=n
self.parent=list(range(n))
self.size=[1]*n
#print(self.size, end=" self.size \n")
def find(self,x):
if self.parent[x]==x:
return x
else:
self.parent[x]=self.find(self.parent[x])
return self.parent[x]
def union(self,x,y):
x=self.find(x)
y=self.find(y)
if x==y:
return
else:
if self.size[x]>=self.size[y]:
self.parent[y]=x
self.size[x]+=self.size[y]
else:
self.parent[x]=y
self.size[y]+=self.size[x]
def cnt(self,x):
return self.size[self.find(x)]
def main():
n,m,k=list(map(int,input().split()))
u=UnionFind(n)
ans=[0]*n
for _ in range(m):
a,b=list(map(int,input().split()))
a-=1
b-=1
u.union(a,b)
ans[a]-=1
ans[b]-=1
for _ in range(k):
c,d=list(map(int,input().split()))
c-=1
d-=1
if u.find(c)==u.find(d):
ans[c]-=1
ans[d]-=1
for i in range(n):
ans[i]+=u.cnt(i)-1
print((" ".join(map(str,ans))))
main()
|
import sys
input=sys.stdin.readline
class UnionFind():
def __init__(self,n):
self.n=n
self.parent=list(range(n))
self.size=[1]*n
#print(self.size, end=" self.size \n")
def find(self,x):
if self.parent[x]==x:
return x
else:
self.parent[x]=self.find(self.parent[x])
return self.parent[x]
def union(self,x,y):
x=self.find(x)
y=self.find(y)
if x==y:
return
else:
if self.size[x]>=self.size[y]:
self.parent[y]=x
self.size[x]+=self.size[y]
else:
self.parent[x]=y
self.size[y]+=self.size[x]
def cnt(self,x):
return self.size[self.find(x)]
def main():
n,m,k=list(map(int,input().split()))
u=UnionFind(n)
ans=[0]*n
for _ in range(m):
a,b=list(map(int,input().split()))
a-=1
b-=1
u.union(a,b)
ans[a]-=1
ans[b]-=1
for _ in range(k):
c,d=list(map(int,input().split()))
c-=1
d-=1
if u.find(c)==u.find(d):
ans[c]-=1
ans[d]-=1
for i in range(n):
ans[i]+=u.cnt(i)-1
print((" ".join(map(str,ans))))
main()
| 50 | 50 | 1,109 | 1,108 |
import sys
# input=sys.stdin.readline
class UnionFind:
def __init__(self, n):
self.n = n
self.parent = list(range(n))
self.size = [1] * n
# print(self.size, end=" self.size \n")
def find(self, x):
if self.parent[x] == x:
return x
else:
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
else:
if self.size[x] >= self.size[y]:
self.parent[y] = x
self.size[x] += self.size[y]
else:
self.parent[x] = y
self.size[y] += self.size[x]
def cnt(self, x):
return self.size[self.find(x)]
def main():
n, m, k = list(map(int, input().split()))
u = UnionFind(n)
ans = [0] * n
for _ in range(m):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
u.union(a, b)
ans[a] -= 1
ans[b] -= 1
for _ in range(k):
c, d = list(map(int, input().split()))
c -= 1
d -= 1
if u.find(c) == u.find(d):
ans[c] -= 1
ans[d] -= 1
for i in range(n):
ans[i] += u.cnt(i) - 1
print((" ".join(map(str, ans))))
main()
|
import sys
input = sys.stdin.readline
class UnionFind:
def __init__(self, n):
self.n = n
self.parent = list(range(n))
self.size = [1] * n
# print(self.size, end=" self.size \n")
def find(self, x):
if self.parent[x] == x:
return x
else:
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
else:
if self.size[x] >= self.size[y]:
self.parent[y] = x
self.size[x] += self.size[y]
else:
self.parent[x] = y
self.size[y] += self.size[x]
def cnt(self, x):
return self.size[self.find(x)]
def main():
n, m, k = list(map(int, input().split()))
u = UnionFind(n)
ans = [0] * n
for _ in range(m):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
u.union(a, b)
ans[a] -= 1
ans[b] -= 1
for _ in range(k):
c, d = list(map(int, input().split()))
c -= 1
d -= 1
if u.find(c) == u.find(d):
ans[c] -= 1
ans[d] -= 1
for i in range(n):
ans[i] += u.cnt(i) - 1
print((" ".join(map(str, ans))))
main()
| false | 0 |
[
"-# input=sys.stdin.readline",
"+input = sys.stdin.readline",
"+",
"+"
] | false | 0.085334 | 0.037317 | 2.286771 |
[
"s093498133",
"s418614808"
] |
u140201022
|
p00008
|
python
|
s060046856
|
s366125957
| 310 | 110 | 5,252 | 4,200 |
Accepted
|
Accepted
| 64.52 |
import itertools
import sys
s=list(range(0,10))
chk=list(itertools.product(s,repeat=4))
for j in sys.stdin:
ans=0
for k in chk:
if sum(k)==int(j):
ans+=1
print(ans)
|
while 1:
try:
n=int(input())
except EOFError:
break
print(len([1 for i in range(10) for j in range(10) for k in range(10) for l in range(10) if i+j+k+l==n]))
| 10 | 6 | 198 | 193 |
import itertools
import sys
s = list(range(0, 10))
chk = list(itertools.product(s, repeat=4))
for j in sys.stdin:
ans = 0
for k in chk:
if sum(k) == int(j):
ans += 1
print(ans)
|
while 1:
try:
n = int(input())
except EOFError:
break
print(
len(
[
1
for i in range(10)
for j in range(10)
for k in range(10)
for l in range(10)
if i + j + k + l == n
]
)
)
| false | 40 |
[
"-import itertools",
"-import sys",
"-",
"-s = list(range(0, 10))",
"-chk = list(itertools.product(s, repeat=4))",
"-for j in sys.stdin:",
"- ans = 0",
"- for k in chk:",
"- if sum(k) == int(j):",
"- ans += 1",
"- print(ans)",
"+while 1:",
"+ try:",
"+ n = int(input())",
"+ except EOFError:",
"+ break",
"+ print(",
"+ len(",
"+ [",
"+ 1",
"+ for i in range(10)",
"+ for j in range(10)",
"+ for k in range(10)",
"+ for l in range(10)",
"+ if i + j + k + l == n",
"+ ]",
"+ )",
"+ )"
] | false | 0.04542 | 0.088881 | 0.511018 |
[
"s060046856",
"s366125957"
] |
u573900545
|
p02695
|
python
|
s453791025
|
s750595202
| 1,990 | 239 | 21,564 | 46,516 |
Accepted
|
Accepted
| 87.99 |
import itertools
N, M, Q = list(map(int, input().split()))
max = 0
s = ''
for i in range(M):
s += str(i)
l = list(itertools.combinations_with_replacement(s, N))
m = [list(map(int, input().split())) for i in range(Q)]
for x in l:
count = 0
for y in m:
if int(x[y[1] - 1]) - int(x[y[0] - 1]) == y[2]:
count += y[3]
if count > max:
max = count
print(max)
|
#cited from maspy
import itertools
import numpy as np
N, M, Q = list(map(int, input().split()))
A = np.array(list(itertools.combinations_with_replacement(list(range(1, M + 1)), N)))
n = len(A)
score = np.zeros(n, np.int32)
m = [list(map(int, input().split())) for i in range(Q)]
for a, b, c, d in m:
cond = A[:, b - 1] - A[:, a - 1] == c
score += d * cond
print((score.max()))
| 16 | 13 | 404 | 383 |
import itertools
N, M, Q = list(map(int, input().split()))
max = 0
s = ""
for i in range(M):
s += str(i)
l = list(itertools.combinations_with_replacement(s, N))
m = [list(map(int, input().split())) for i in range(Q)]
for x in l:
count = 0
for y in m:
if int(x[y[1] - 1]) - int(x[y[0] - 1]) == y[2]:
count += y[3]
if count > max:
max = count
print(max)
|
# cited from maspy
import itertools
import numpy as np
N, M, Q = list(map(int, input().split()))
A = np.array(list(itertools.combinations_with_replacement(list(range(1, M + 1)), N)))
n = len(A)
score = np.zeros(n, np.int32)
m = [list(map(int, input().split())) for i in range(Q)]
for a, b, c, d in m:
cond = A[:, b - 1] - A[:, a - 1] == c
score += d * cond
print((score.max()))
| false | 18.75 |
[
"+# cited from maspy",
"+import numpy as np",
"-max = 0",
"-s = \"\"",
"-for i in range(M):",
"- s += str(i)",
"-l = list(itertools.combinations_with_replacement(s, N))",
"+A = np.array(list(itertools.combinations_with_replacement(list(range(1, M + 1)), N)))",
"+n = len(A)",
"+score = np.zeros(n, np.int32)",
"-for x in l:",
"- count = 0",
"- for y in m:",
"- if int(x[y[1] - 1]) - int(x[y[0] - 1]) == y[2]:",
"- count += y[3]",
"- if count > max:",
"- max = count",
"-print(max)",
"+for a, b, c, d in m:",
"+ cond = A[:, b - 1] - A[:, a - 1] == c",
"+ score += d * cond",
"+print((score.max()))"
] | false | 0.050672 | 0.318895 | 0.158898 |
[
"s453791025",
"s750595202"
] |
u167751176
|
p03309
|
python
|
s074530615
|
s164253470
| 217 | 193 | 26,176 | 26,832 |
Accepted
|
Accepted
| 11.06 |
def main():
N = int(eval(input()))
A = list(map(int, input().split()))
for i in range(N):
A[i] -= i+1
A.sort()
mid1 = A[N//2]
mid2 = A[N//2]
if N >= 2:
mid2 = A[N//2 + 1]
ans1 = 0
ans2 = 0
for i in range(N):
ans1 += abs(A[i] - mid1)
ans2 += abs(A[i] - mid2)
print((min(ans1, ans2)))
if __name__ == '__main__':
main()
|
def main():
N = int(eval(input()))
A = list(map(int, input().split()))
for i in range(N):
A[i] -= i+1
A.sort()
mid = A[N//2]
ans = 0
for i in range(N):
ans += abs(A[i] - mid)
print(ans)
if __name__ == '__main__':
main()
| 24 | 17 | 360 | 249 |
def main():
N = int(eval(input()))
A = list(map(int, input().split()))
for i in range(N):
A[i] -= i + 1
A.sort()
mid1 = A[N // 2]
mid2 = A[N // 2]
if N >= 2:
mid2 = A[N // 2 + 1]
ans1 = 0
ans2 = 0
for i in range(N):
ans1 += abs(A[i] - mid1)
ans2 += abs(A[i] - mid2)
print((min(ans1, ans2)))
if __name__ == "__main__":
main()
|
def main():
N = int(eval(input()))
A = list(map(int, input().split()))
for i in range(N):
A[i] -= i + 1
A.sort()
mid = A[N // 2]
ans = 0
for i in range(N):
ans += abs(A[i] - mid)
print(ans)
if __name__ == "__main__":
main()
| false | 29.166667 |
[
"- mid1 = A[N // 2]",
"- mid2 = A[N // 2]",
"- if N >= 2:",
"- mid2 = A[N // 2 + 1]",
"- ans1 = 0",
"- ans2 = 0",
"+ mid = A[N // 2]",
"+ ans = 0",
"- ans1 += abs(A[i] - mid1)",
"- ans2 += abs(A[i] - mid2)",
"- print((min(ans1, ans2)))",
"+ ans += abs(A[i] - mid)",
"+ print(ans)"
] | false | 0.036885 | 0.04115 | 0.89636 |
[
"s074530615",
"s164253470"
] |
u881590806
|
p02257
|
python
|
s690510229
|
s759608820
| 1,750 | 830 | 6,944 | 6,880 |
Accepted
|
Accepted
| 52.57 |
n = int(input())
a = []
for i in range(n):
a.append(int(input()))
nprimes = 0
a = sorted(a)
while True:
for d in range(2,10001):
if d**2>a[0]:
nprimes+=1
del a[0]
break
elif a[0]%d==0:
del a[0]
break
if len(a) <= 0:
break
print(nprimes)
|
def prime(num):
if num == 0:
return False
elif num == 1:
return False
elif num == 2:
return True
i = 2
while True:
if i**2 > num:
break
if num%i==0:
return False
i += 1
return True
n = int(input())
nums = []
for _ in range(n):
a = int(input())
nums.append(a)
ret = 0
for num in nums:
if prime(num):
ret += 1
print(ret)
| 20 | 27 | 360 | 469 |
n = int(input())
a = []
for i in range(n):
a.append(int(input()))
nprimes = 0
a = sorted(a)
while True:
for d in range(2, 10001):
if d**2 > a[0]:
nprimes += 1
del a[0]
break
elif a[0] % d == 0:
del a[0]
break
if len(a) <= 0:
break
print(nprimes)
|
def prime(num):
if num == 0:
return False
elif num == 1:
return False
elif num == 2:
return True
i = 2
while True:
if i**2 > num:
break
if num % i == 0:
return False
i += 1
return True
n = int(input())
nums = []
for _ in range(n):
a = int(input())
nums.append(a)
ret = 0
for num in nums:
if prime(num):
ret += 1
print(ret)
| false | 25.925926 |
[
"+def prime(num):",
"+ if num == 0:",
"+ return False",
"+ elif num == 1:",
"+ return False",
"+ elif num == 2:",
"+ return True",
"+ i = 2",
"+ while True:",
"+ if i**2 > num:",
"+ break",
"+ if num % i == 0:",
"+ return False",
"+ i += 1",
"+ return True",
"+",
"+",
"-a = []",
"-for i in range(n):",
"- a.append(int(input()))",
"-nprimes = 0",
"-a = sorted(a)",
"-while True:",
"- for d in range(2, 10001):",
"- if d**2 > a[0]:",
"- nprimes += 1",
"- del a[0]",
"- break",
"- elif a[0] % d == 0:",
"- del a[0]",
"- break",
"- if len(a) <= 0:",
"- break",
"-print(nprimes)",
"+nums = []",
"+for _ in range(n):",
"+ a = int(input())",
"+ nums.append(a)",
"+ret = 0",
"+for num in nums:",
"+ if prime(num):",
"+ ret += 1",
"+print(ret)"
] | false | 0.036789 | 0.037928 | 0.969962 |
[
"s690510229",
"s759608820"
] |
u941438707
|
p02971
|
python
|
s297634456
|
s236181676
| 483 | 429 | 18,804 | 26,060 |
Accepted
|
Accepted
| 11.18 |
n=int(input())
a=[int(input()) for _ in range(n)]
b=sorted(a)
ans=[b[-1]]*n
ans[a.index(b[-1])]=b[-2]
print(*ans,sep="\n")
|
from copy import deepcopy
n,*a=list(map(int,open(0).read().split()))
b=deepcopy(a)
b.sort()
c=b[-1]
for i in a:
if i==b[-1]:
print((b[-2]))
else:
print(c)
| 6 | 10 | 127 | 179 |
n = int(input())
a = [int(input()) for _ in range(n)]
b = sorted(a)
ans = [b[-1]] * n
ans[a.index(b[-1])] = b[-2]
print(*ans, sep="\n")
|
from copy import deepcopy
n, *a = list(map(int, open(0).read().split()))
b = deepcopy(a)
b.sort()
c = b[-1]
for i in a:
if i == b[-1]:
print((b[-2]))
else:
print(c)
| false | 40 |
[
"-n = int(input())",
"-a = [int(input()) for _ in range(n)]",
"-b = sorted(a)",
"-ans = [b[-1]] * n",
"-ans[a.index(b[-1])] = b[-2]",
"-print(*ans, sep=\"\\n\")",
"+from copy import deepcopy",
"+",
"+n, *a = list(map(int, open(0).read().split()))",
"+b = deepcopy(a)",
"+b.sort()",
"+c = b[-1]",
"+for i in a:",
"+ if i == b[-1]:",
"+ print((b[-2]))",
"+ else:",
"+ print(c)"
] | false | 0.0394 | 0.047609 | 0.827574 |
[
"s297634456",
"s236181676"
] |
u600402037
|
p03682
|
python
|
s212464626
|
s065157669
| 1,557 | 1,429 | 63,012 | 53,544 |
Accepted
|
Accepted
| 8.22 |
from heapq import *
# Aの中でxの根を求める
def find(A,x):
p = A[x]
if p == x:
return x
a = find(A,p)
A[x] = a
return a
# Aのリストでxとyの属する集合の併合
def union(A, x, y):
if find(A,x) > find(A,y):
bx, by = find(A,y), find(A,x)
else:
bx, by = find(A,x), find(A,y)
# 根をbxに統一
A[by] = bx
N = int(eval(input()))
X = [(0,0)] * N
Y = [(0,0)] * N
E = [(0,0)] * N
for i in range(N):
x, y = list(map(int, input().split()))
X[i] = (x, i)
Y[i] = (y, i)
E[i] = (x, y)
X.sort()
Y.sort()
H = []
heapify(H)
for i in range(N - 1):
x1, j1 = X[i]
x2, j2 = X[i + 1]
y1, k1 = Y[i]
y2, k2 = Y[i + 1]
# ヒープ構造を用いて常にHの最初に最小値を持ってくる
# X座標とY座標でそれぞれHに追加
heappush(H, (x2 - x1, j1, j2))
heappush(H, (y2 - y1, k1, k2))
answer = 0
V = [i for i in range(N)]
while H:
w, s, t = heappop(H)
# sとtの集合が異なっていた時、道を作る
if find(V, s) != find(V, t):
union(V, s, t)
answer += w
print(answer)
|
# D - Built?
from heapq import *
# Aでxの根を求める
def find(A, x):
p = A[x]
if p == x:
return x
a = find(A, p)
A[x] = a
return a
# Aでxとyの属する集合の併合
def union(A, x, y):
if find(A, x) > find(A, y):
bx, by = find(A, y), find(A, x)
else:
bx, by = find(A, x), find(A, y)
# 根をbx(値の小さい方)に統一
A[by] = bx
N = int(eval(input()))
X = [(0,0)] * N
Y = [(0,0)] * N
for i in range(N):
x, y = list(map(int, input().split()))
X[i] = (x, i)
Y[i] = (y, i)
X.sort()
Y.sort()
H = []
heapify(H)
for i in range(N - 1):
x1, j1 = X[i]
x2, j2 = X[i+1]
y1, k1 = Y[i]
y2, k2 = Y[i+1]
# ヒープ構造を用いて常にHの先頭に最小値を持ってくる
# X座標とY座標でそれぞれHに追加
heappush(H, (x2 - x1, j1, j2))
heappush(H, (y2 - y1, k1, k2))
answer = 0
V = [i for i in range(N)]
while H:
w, s, t = heappop(H)
# sとtの集合が異なっていた時、道を作る
if find(V, s) != find(V, t):
union(V, s, t)
answer += w
print(answer)
| 57 | 56 | 1,015 | 999 |
from heapq import *
# Aの中でxの根を求める
def find(A, x):
p = A[x]
if p == x:
return x
a = find(A, p)
A[x] = a
return a
# Aのリストでxとyの属する集合の併合
def union(A, x, y):
if find(A, x) > find(A, y):
bx, by = find(A, y), find(A, x)
else:
bx, by = find(A, x), find(A, y)
# 根をbxに統一
A[by] = bx
N = int(eval(input()))
X = [(0, 0)] * N
Y = [(0, 0)] * N
E = [(0, 0)] * N
for i in range(N):
x, y = list(map(int, input().split()))
X[i] = (x, i)
Y[i] = (y, i)
E[i] = (x, y)
X.sort()
Y.sort()
H = []
heapify(H)
for i in range(N - 1):
x1, j1 = X[i]
x2, j2 = X[i + 1]
y1, k1 = Y[i]
y2, k2 = Y[i + 1]
# ヒープ構造を用いて常にHの最初に最小値を持ってくる
# X座標とY座標でそれぞれHに追加
heappush(H, (x2 - x1, j1, j2))
heappush(H, (y2 - y1, k1, k2))
answer = 0
V = [i for i in range(N)]
while H:
w, s, t = heappop(H)
# sとtの集合が異なっていた時、道を作る
if find(V, s) != find(V, t):
union(V, s, t)
answer += w
print(answer)
|
# D - Built?
from heapq import *
# Aでxの根を求める
def find(A, x):
p = A[x]
if p == x:
return x
a = find(A, p)
A[x] = a
return a
# Aでxとyの属する集合の併合
def union(A, x, y):
if find(A, x) > find(A, y):
bx, by = find(A, y), find(A, x)
else:
bx, by = find(A, x), find(A, y)
# 根をbx(値の小さい方)に統一
A[by] = bx
N = int(eval(input()))
X = [(0, 0)] * N
Y = [(0, 0)] * N
for i in range(N):
x, y = list(map(int, input().split()))
X[i] = (x, i)
Y[i] = (y, i)
X.sort()
Y.sort()
H = []
heapify(H)
for i in range(N - 1):
x1, j1 = X[i]
x2, j2 = X[i + 1]
y1, k1 = Y[i]
y2, k2 = Y[i + 1]
# ヒープ構造を用いて常にHの先頭に最小値を持ってくる
# X座標とY座標でそれぞれHに追加
heappush(H, (x2 - x1, j1, j2))
heappush(H, (y2 - y1, k1, k2))
answer = 0
V = [i for i in range(N)]
while H:
w, s, t = heappop(H)
# sとtの集合が異なっていた時、道を作る
if find(V, s) != find(V, t):
union(V, s, t)
answer += w
print(answer)
| false | 1.754386 |
[
"+# D - Built?",
"-# Aの中でxの根を求める",
"+# Aでxの根を求める",
"-# Aのリストでxとyの属する集合の併合",
"+# Aでxとyの属する集合の併合",
"- # 根をbxに統一",
"+ # 根をbx(値の小さい方)に統一",
"-E = [(0, 0)] * N",
"- E[i] = (x, y)",
"- # ヒープ構造を用いて常にHの最初に最小値を持ってくる",
"+ # ヒープ構造を用いて常にHの先頭に最小値を持ってくる"
] | false | 0.0529 | 0.0507 | 1.043395 |
[
"s212464626",
"s065157669"
] |
u868716420
|
p02258
|
python
|
s779080449
|
s675550577
| 570 | 500 | 7,692 | 7,692 |
Accepted
|
Accepted
| 12.28 |
res = -10 ** 9
n = int(eval(input()))
a = int(eval(input()))
Min = int(a)
for mak in range(n - 1) :
tem = 0
b = int(eval(input()))
Min = min(b, Min)
if b < a : tem = b - a
else : tem = b - Min
if tem > res : res = int(tem)
a = int(b)
print(res)
|
res = -10 ** 9
n = int(eval(input()))
a = int(eval(input()))
Min = int(a)
for mak in range(n - 1) :
tem = 0
b = int(eval(input()))
if b < Min : Min = int(b)
if b < a : tem = b - a
else : tem = b - Min
if tem > res : res = int(tem)
a = int(b)
print(res)
| 16 | 16 | 290 | 298 |
res = -(10**9)
n = int(eval(input()))
a = int(eval(input()))
Min = int(a)
for mak in range(n - 1):
tem = 0
b = int(eval(input()))
Min = min(b, Min)
if b < a:
tem = b - a
else:
tem = b - Min
if tem > res:
res = int(tem)
a = int(b)
print(res)
|
res = -(10**9)
n = int(eval(input()))
a = int(eval(input()))
Min = int(a)
for mak in range(n - 1):
tem = 0
b = int(eval(input()))
if b < Min:
Min = int(b)
if b < a:
tem = b - a
else:
tem = b - Min
if tem > res:
res = int(tem)
a = int(b)
print(res)
| false | 0 |
[
"- Min = min(b, Min)",
"+ if b < Min:",
"+ Min = int(b)"
] | false | 0.043692 | 0.040377 | 1.082089 |
[
"s779080449",
"s675550577"
] |
u556358547
|
p03854
|
python
|
s753739254
|
s283859243
| 1,932 | 145 | 228,552 | 78,128 |
Accepted
|
Accepted
| 92.49 |
# vim: fileencoding=utf-8
def main():
s = list(eval(input()))
c = ["dreamer", "dream", "erase", "eraser"]
n = [7, 5, 5, 6]
while True:
f = True
for i in range(4):
if "".join(s[-n[i] :]) == c[i]:
f = False
s = s[: -n[i]]
break
if f:
if len(s) == 0:
print("YES")
else:
print("NO")
return
if __name__ == "__main__":
main()
|
# vim: fileencoding=utf-8
def main():
s = eval(input())
c = ["dreamer", "dream", "erase", "eraser"]
n = [7, 5, 5, 6]
while True:
f = True
for i in range(4):
if s[-n[i] :] == c[i]:
f = False
s = s[: -n[i]]
break
if f:
if len(s) == 0:
print("YES")
else:
print("NO")
return
if __name__ == "__main__":
main()
| 24 | 24 | 513 | 498 |
# vim: fileencoding=utf-8
def main():
s = list(eval(input()))
c = ["dreamer", "dream", "erase", "eraser"]
n = [7, 5, 5, 6]
while True:
f = True
for i in range(4):
if "".join(s[-n[i] :]) == c[i]:
f = False
s = s[: -n[i]]
break
if f:
if len(s) == 0:
print("YES")
else:
print("NO")
return
if __name__ == "__main__":
main()
|
# vim: fileencoding=utf-8
def main():
s = eval(input())
c = ["dreamer", "dream", "erase", "eraser"]
n = [7, 5, 5, 6]
while True:
f = True
for i in range(4):
if s[-n[i] :] == c[i]:
f = False
s = s[: -n[i]]
break
if f:
if len(s) == 0:
print("YES")
else:
print("NO")
return
if __name__ == "__main__":
main()
| false | 0 |
[
"- s = list(eval(input()))",
"+ s = eval(input())",
"- if \"\".join(s[-n[i] :]) == c[i]:",
"+ if s[-n[i] :] == c[i]:"
] | false | 0.090167 | 0.040097 | 2.248735 |
[
"s753739254",
"s283859243"
] |
u784022244
|
p02802
|
python
|
s000529780
|
s911954574
| 858 | 265 | 14,804 | 3,828 |
Accepted
|
Accepted
| 69.11 |
N, M=list(map(int, input().split()))
import numpy as np
pena=np.array([0]*N)
status=np.array([0]*N)
for i in range(M):
p,s=tuple(input().split())
p=int(p)
if s=="WA":
if status[p-1]!=1:
pena[p-1]+=1
if s=="AC":
if status[p-1]!=1:
status[p-1]=1
nac=sum(status)
npena=sum(pena*status)
print((nac, npena))
|
N,M=list(map(int, input().split()))
now=[0]*N
pena=0
for i in range(M):
num,result=input().split()
num=int(num)-1
if result=="AC":
if now[num]>0:
pena+=now[num]
now[num]=-1
else:
if now[num]>=0:
now[num]+=1
print((now.count(-1), pena))
| 19 | 14 | 343 | 305 |
N, M = list(map(int, input().split()))
import numpy as np
pena = np.array([0] * N)
status = np.array([0] * N)
for i in range(M):
p, s = tuple(input().split())
p = int(p)
if s == "WA":
if status[p - 1] != 1:
pena[p - 1] += 1
if s == "AC":
if status[p - 1] != 1:
status[p - 1] = 1
nac = sum(status)
npena = sum(pena * status)
print((nac, npena))
|
N, M = list(map(int, input().split()))
now = [0] * N
pena = 0
for i in range(M):
num, result = input().split()
num = int(num) - 1
if result == "AC":
if now[num] > 0:
pena += now[num]
now[num] = -1
else:
if now[num] >= 0:
now[num] += 1
print((now.count(-1), pena))
| false | 26.315789 |
[
"-import numpy as np",
"-",
"-pena = np.array([0] * N)",
"-status = np.array([0] * N)",
"+now = [0] * N",
"+pena = 0",
"- p, s = tuple(input().split())",
"- p = int(p)",
"- if s == \"WA\":",
"- if status[p - 1] != 1:",
"- pena[p - 1] += 1",
"- if s == \"AC\":",
"- if status[p - 1] != 1:",
"- status[p - 1] = 1",
"-nac = sum(status)",
"-npena = sum(pena * status)",
"-print((nac, npena))",
"+ num, result = input().split()",
"+ num = int(num) - 1",
"+ if result == \"AC\":",
"+ if now[num] > 0:",
"+ pena += now[num]",
"+ now[num] = -1",
"+ else:",
"+ if now[num] >= 0:",
"+ now[num] += 1",
"+print((now.count(-1), pena))"
] | false | 0.204332 | 0.006962 | 29.348119 |
[
"s000529780",
"s911954574"
] |
u832152513
|
p03730
|
python
|
s958087239
|
s532889781
| 167 | 110 | 38,384 | 61,484 |
Accepted
|
Accepted
| 34.13 |
a, b, c = list(map(int, input().split()))
for i in range(1, 100):
if a * i % b == c:
print("YES")
exit()
print("NO")
|
a, b, c = list(map(int, input().split()))
for i in range(1, 200):
if a*i % b == c:
print("YES")
exit()
print("NO")
| 8 | 7 | 139 | 135 |
a, b, c = list(map(int, input().split()))
for i in range(1, 100):
if a * i % b == c:
print("YES")
exit()
print("NO")
|
a, b, c = list(map(int, input().split()))
for i in range(1, 200):
if a * i % b == c:
print("YES")
exit()
print("NO")
| false | 12.5 |
[
"-for i in range(1, 100):",
"+for i in range(1, 200):"
] | false | 0.036418 | 0.035424 | 1.028067 |
[
"s958087239",
"s532889781"
] |
u802963389
|
p03038
|
python
|
s189466999
|
s323206320
| 613 | 356 | 36,088 | 36,068 |
Accepted
|
Accepted
| 41.92 |
n, m = list(map(int, input().split()))
A = list(map(int, input().split()))
BC = [list(map(int, input().split())) for _ in range(m)]
A.sort()
BC.sort(key=lambda k: -k[1])
stack = []
cnt = 0
for b, c in BC:
for _ in range(b):
stack.append(c)
cnt += 1
if cnt > n:
break
for i in range(min(n, len(stack))):
if A[i] < stack[i]:
A[i] = stack[i]
else:
break
print((sum(A)))
|
from itertools import zip_longest
n, m = list(map(int, input().split()))
A = list(map(int, input().split()))
BC = [list(map(int, input().split())) for _ in range(m)]
A.sort()
BC.sort(key=lambda x: -x[1])
stack = []
i = 0
while len(stack) < n and i < m:
for _ in range(BC[i][0]):
stack.append(BC[i][1])
if len(stack) >= n:
break
i += 1
ans = 0
for a, s in zip_longest(A, stack, fillvalue=0):
ans += max(a, s)
print(ans)
| 23 | 23 | 420 | 459 |
n, m = list(map(int, input().split()))
A = list(map(int, input().split()))
BC = [list(map(int, input().split())) for _ in range(m)]
A.sort()
BC.sort(key=lambda k: -k[1])
stack = []
cnt = 0
for b, c in BC:
for _ in range(b):
stack.append(c)
cnt += 1
if cnt > n:
break
for i in range(min(n, len(stack))):
if A[i] < stack[i]:
A[i] = stack[i]
else:
break
print((sum(A)))
|
from itertools import zip_longest
n, m = list(map(int, input().split()))
A = list(map(int, input().split()))
BC = [list(map(int, input().split())) for _ in range(m)]
A.sort()
BC.sort(key=lambda x: -x[1])
stack = []
i = 0
while len(stack) < n and i < m:
for _ in range(BC[i][0]):
stack.append(BC[i][1])
if len(stack) >= n:
break
i += 1
ans = 0
for a, s in zip_longest(A, stack, fillvalue=0):
ans += max(a, s)
print(ans)
| false | 0 |
[
"+from itertools import zip_longest",
"+",
"-BC.sort(key=lambda k: -k[1])",
"+BC.sort(key=lambda x: -x[1])",
"-cnt = 0",
"-for b, c in BC:",
"- for _ in range(b):",
"- stack.append(c)",
"- cnt += 1",
"- if cnt > n:",
"+i = 0",
"+while len(stack) < n and i < m:",
"+ for _ in range(BC[i][0]):",
"+ stack.append(BC[i][1])",
"+ if len(stack) >= n:",
"-for i in range(min(n, len(stack))):",
"- if A[i] < stack[i]:",
"- A[i] = stack[i]",
"- else:",
"- break",
"-print((sum(A)))",
"+ i += 1",
"+ans = 0",
"+for a, s in zip_longest(A, stack, fillvalue=0):",
"+ ans += max(a, s)",
"+print(ans)"
] | false | 0.101002 | 0.036222 | 2.788426 |
[
"s189466999",
"s323206320"
] |
u918276501
|
p02258
|
python
|
s975020120
|
s892701027
| 520 | 240 | 7,684 | 21,748 |
Accepted
|
Accepted
| 53.85 |
N = int(eval(input()))
M = -1000000000
L = int(eval(input()))
for i in range(1,N):
C = int(eval(input()))
M = max(C - L, M)
L = min(C, L)
print(M)
|
import sys
eval(input())
a,b=-1e11,1e11
for i in map(int,sys.stdin.readlines()):
a=max(a,i-b)
b=min(i,b)
print(a)
| 8 | 7 | 147 | 117 |
N = int(eval(input()))
M = -1000000000
L = int(eval(input()))
for i in range(1, N):
C = int(eval(input()))
M = max(C - L, M)
L = min(C, L)
print(M)
|
import sys
eval(input())
a, b = -1e11, 1e11
for i in map(int, sys.stdin.readlines()):
a = max(a, i - b)
b = min(i, b)
print(a)
| false | 12.5 |
[
"-N = int(eval(input()))",
"-M = -1000000000",
"-L = int(eval(input()))",
"-for i in range(1, N):",
"- C = int(eval(input()))",
"- M = max(C - L, M)",
"- L = min(C, L)",
"-print(M)",
"+import sys",
"+",
"+eval(input())",
"+a, b = -1e11, 1e11",
"+for i in map(int, sys.stdin.readlines()):",
"+ a = max(a, i - b)",
"+ b = min(i, b)",
"+print(a)"
] | false | 0.044309 | 0.044677 | 0.991763 |
[
"s975020120",
"s892701027"
] |
u813387707
|
p03679
|
python
|
s400991039
|
s683762268
| 31 | 24 | 9,064 | 9,172 |
Accepted
|
Accepted
| 22.58 |
x, a, b = [int(s) for s in input().split()]
print(("delicious" if b <= a else ("safe" if b <= a + x else "dangerous")))
|
x, a, b = [int(s) for s in input().split()]
if b <= a:
ans = "delicious"
elif b <= a + x:
ans = "safe"
else:
ans = "dangerous"
print(ans)
| 2 | 8 | 118 | 156 |
x, a, b = [int(s) for s in input().split()]
print(("delicious" if b <= a else ("safe" if b <= a + x else "dangerous")))
|
x, a, b = [int(s) for s in input().split()]
if b <= a:
ans = "delicious"
elif b <= a + x:
ans = "safe"
else:
ans = "dangerous"
print(ans)
| false | 75 |
[
"-print((\"delicious\" if b <= a else (\"safe\" if b <= a + x else \"dangerous\")))",
"+if b <= a:",
"+ ans = \"delicious\"",
"+elif b <= a + x:",
"+ ans = \"safe\"",
"+else:",
"+ ans = \"dangerous\"",
"+print(ans)"
] | false | 0.035909 | 0.043041 | 0.834299 |
[
"s400991039",
"s683762268"
] |
u054825571
|
p03038
|
python
|
s374090591
|
s996213215
| 423 | 340 | 104,324 | 39,060 |
Accepted
|
Accepted
| 19.62 |
N,M=list(map(int,input().split()))
A=list(map(int,input().split()))
L=[(1,a) for a in A]
for _ in range(M):
b,c=list(map(int,input().split()))
L.append((b,c))
L=sorted(L,key=lambda x: x[1],reverse=True)
ans,k=0,0
for n,a in L:
if n+k>=N:
ans+=a*(N-k)
break
else:
ans+=a*n
k+=n
print(ans)
|
N,M=list(map(int,input().split()))
L=[(1,a) for a in map(int,input().split())]
for _ in range(M):
L.append(tuple(map(int,input().split())))
L=sorted(L,key=lambda x: x[1],reverse=True)
ans,k=0,0
for n,a in L:
if n+k>=N:
ans+=a*(N-k)
break
else:
ans+=a*n
k+=n
print(ans)
| 16 | 14 | 308 | 297 |
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
L = [(1, a) for a in A]
for _ in range(M):
b, c = list(map(int, input().split()))
L.append((b, c))
L = sorted(L, key=lambda x: x[1], reverse=True)
ans, k = 0, 0
for n, a in L:
if n + k >= N:
ans += a * (N - k)
break
else:
ans += a * n
k += n
print(ans)
|
N, M = list(map(int, input().split()))
L = [(1, a) for a in map(int, input().split())]
for _ in range(M):
L.append(tuple(map(int, input().split())))
L = sorted(L, key=lambda x: x[1], reverse=True)
ans, k = 0, 0
for n, a in L:
if n + k >= N:
ans += a * (N - k)
break
else:
ans += a * n
k += n
print(ans)
| false | 12.5 |
[
"-A = list(map(int, input().split()))",
"-L = [(1, a) for a in A]",
"+L = [(1, a) for a in map(int, input().split())]",
"- b, c = list(map(int, input().split()))",
"- L.append((b, c))",
"+ L.append(tuple(map(int, input().split())))"
] | false | 0.038655 | 0.075225 | 0.513858 |
[
"s374090591",
"s996213215"
] |
u600402037
|
p02839
|
python
|
s367136445
|
s982234629
| 643 | 429 | 184,940 | 173,484 |
Accepted
|
Accepted
| 33.28 |
import sys
import numpy as np
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
H, W = lr()
A = np.array([lr() for _ in range(H)])
B = np.array([lr() for _ in range(H)])
diff = np.abs(A - B).tolist()
X = (H+W) * 80
L = X + X + 1 #真ん中を0とする、最後に-X
dp = [[np.zeros(L, np.bool)] * W for _ in range(H)]
dp[0][0] = np.zeros(L, np.bool)
di = diff[0][0]
dp[0][0][X+di] = 1; dp[0][0][X-di] = 1
for h in range(H):
for w in range(W):
if h == 0 and w == 0:
continue
di = diff[h][w]
x = np.zeros(L, np.bool)
if h > 0:
prev = dp[h-1][w]
x[di:] |= prev[:L-di]
x[:L-di] |= prev[di:]
if w > 0:
prev = dp[h][w-1]
x[di:] |= prev[:L-di]
x[:L-di] |= prev[di:]
dp[h][w] = x
dp = dp[-1][-1][X:]
possible = np.nonzero(dp)[0]
answer = possible.min()
print(answer)
|
import sys
import numpy as np
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
H, W = lr()
A = np.array([lr() for _ in range(H)])
B = np.array([lr() for _ in range(H)])
diff = np.abs(A - B).tolist()
X = (H+W) * 80
L = X + X + 1 #真ん中を0とする、最後に-X
dp = [[np.zeros(L, np.bool) for _ in range(W)] for _ in range(H)]
di = diff[0][0]
dp[0][0][X+di] = 1; dp[0][0][X-di] = 1
for i in range(H):
for j in range(W):
if i == 0 and j == 0:
continue
di = diff[i][j]
if i > 0:
prev = dp[i-1][j]
dp[i][j][di:] |= prev[:L-di]
dp[i][j][:L-di] |= prev[di:]
if j > 0:
prev = dp[i][j-1]
dp[i][j][di:] |= prev[:L-di]
dp[i][j][:L-di] |= prev[di:]
dp = dp[-1][-1][X:]
possible = np.nonzero(dp)[0]
answer = possible.min()
print(answer)
| 38 | 35 | 973 | 926 |
import sys
import numpy as np
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
H, W = lr()
A = np.array([lr() for _ in range(H)])
B = np.array([lr() for _ in range(H)])
diff = np.abs(A - B).tolist()
X = (H + W) * 80
L = X + X + 1 # 真ん中を0とする、最後に-X
dp = [[np.zeros(L, np.bool)] * W for _ in range(H)]
dp[0][0] = np.zeros(L, np.bool)
di = diff[0][0]
dp[0][0][X + di] = 1
dp[0][0][X - di] = 1
for h in range(H):
for w in range(W):
if h == 0 and w == 0:
continue
di = diff[h][w]
x = np.zeros(L, np.bool)
if h > 0:
prev = dp[h - 1][w]
x[di:] |= prev[: L - di]
x[: L - di] |= prev[di:]
if w > 0:
prev = dp[h][w - 1]
x[di:] |= prev[: L - di]
x[: L - di] |= prev[di:]
dp[h][w] = x
dp = dp[-1][-1][X:]
possible = np.nonzero(dp)[0]
answer = possible.min()
print(answer)
|
import sys
import numpy as np
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
H, W = lr()
A = np.array([lr() for _ in range(H)])
B = np.array([lr() for _ in range(H)])
diff = np.abs(A - B).tolist()
X = (H + W) * 80
L = X + X + 1 # 真ん中を0とする、最後に-X
dp = [[np.zeros(L, np.bool) for _ in range(W)] for _ in range(H)]
di = diff[0][0]
dp[0][0][X + di] = 1
dp[0][0][X - di] = 1
for i in range(H):
for j in range(W):
if i == 0 and j == 0:
continue
di = diff[i][j]
if i > 0:
prev = dp[i - 1][j]
dp[i][j][di:] |= prev[: L - di]
dp[i][j][: L - di] |= prev[di:]
if j > 0:
prev = dp[i][j - 1]
dp[i][j][di:] |= prev[: L - di]
dp[i][j][: L - di] |= prev[di:]
dp = dp[-1][-1][X:]
possible = np.nonzero(dp)[0]
answer = possible.min()
print(answer)
| false | 7.894737 |
[
"-dp = [[np.zeros(L, np.bool)] * W for _ in range(H)]",
"-dp[0][0] = np.zeros(L, np.bool)",
"+dp = [[np.zeros(L, np.bool) for _ in range(W)] for _ in range(H)]",
"-for h in range(H):",
"- for w in range(W):",
"- if h == 0 and w == 0:",
"+for i in range(H):",
"+ for j in range(W):",
"+ if i == 0 and j == 0:",
"- di = diff[h][w]",
"- x = np.zeros(L, np.bool)",
"- if h > 0:",
"- prev = dp[h - 1][w]",
"- x[di:] |= prev[: L - di]",
"- x[: L - di] |= prev[di:]",
"- if w > 0:",
"- prev = dp[h][w - 1]",
"- x[di:] |= prev[: L - di]",
"- x[: L - di] |= prev[di:]",
"- dp[h][w] = x",
"+ di = diff[i][j]",
"+ if i > 0:",
"+ prev = dp[i - 1][j]",
"+ dp[i][j][di:] |= prev[: L - di]",
"+ dp[i][j][: L - di] |= prev[di:]",
"+ if j > 0:",
"+ prev = dp[i][j - 1]",
"+ dp[i][j][di:] |= prev[: L - di]",
"+ dp[i][j][: L - di] |= prev[di:]"
] | false | 0.27329 | 0.425804 | 0.64182 |
[
"s367136445",
"s982234629"
] |
u279460955
|
p03634
|
python
|
s597761107
|
s643764387
| 573 | 524 | 132,116 | 153,672 |
Accepted
|
Accepted
| 8.55 |
class RadixHeap:
__slots__ = ["data", "last", "siz", "used"]
# (max_key - min_key) <= C
def __init__(self, N, C):
self.data = [[] for i in range(C.bit_length() + 1000)]
self.last = self.siz = 0
self.used = [0] * N
def push(self, x, key):
# assert self.last <= x
self.siz += 1
self.data[(x ^ self.last).bit_length()].append((x, key))
def pop(self):
data = self.data
used = self.used
# assert self.siz > 0
if not data[0]:
i = 1
while not data[i]:
i += 1
d = data[i]
new_last, new_key = min(d)
used[new_key] = 1
for val in d:
x, key = val
if used[key]:
self.siz -= 1
continue
data[(x ^ new_last).bit_length()].append(val)
self.last = new_last
data[i] = []
else:
new_last, new_key = data[0].pop()
used[new_key] = 1
self.siz -= 1
return new_last, new_key
def __len__(self):
return self.siz
def dijkstra(N, G, s):
que = RadixHeap(N, 10**9 + 1)
dist = [10**18] * N
dist[s] = 0
que.push(0, s)
while que:
cost, v = que.pop()
if dist[v] < cost:
continue
for w, c in G[v]:
if cost + c < dist[w]:
dist[w] = r = cost + c
que.push(r, w)
return dist
# ----------- #
n = int(eval(input()))
ABC = [tuple(int(x) for x in input().split()) for _ in range(n - 1)]
q, k = (int(x) for x in input().split())
queries = [tuple(int(x) for x in input().split()) for _ in range(q)]
G = [[] for _ in range(n)]
for a, b, c in ABC:
a -= 1
b -= 1
G[a].append((b, c))
G[b].append((a, c))
dist = dijkstra(n, G, k-1)
for x, y in queries:
x -= 1
y -= 1
print((dist[x] + dist[y]))
|
class Tree_with_edge_cost:
def __init__(self, n, edge):
self.n = n
self.nexts = [[] for _ in range(n)]
for u, v, c in edge:
self.nexts[u].append((v, c))
self.nexts[v].append((u, c))
self.parent = [-1] * self.n
self.children = [[] for _ in range(self.n)]
self.cost = [0] * self.n
self.dist = [0] * self.n # 根からの距離
self.depth = [0] * self.n # 根からの深さ(cost=1での距離)
self.order = []
def set_root(self, root): # O(n)
self.order.append(root)
stack = [root]
while stack:
v = stack.pop()
for child, cost in self.nexts[v]:
if child == self.parent[v]:
continue
else:
self.parent[child] = v
self.children[v].append(child)
self.depth[child] = self.depth[v] + 1
self.dist[child] = self.dist[v] + cost
self.cost[child] = cost
self.order.append(child)
stack.append(child)
def get_diameter(self, restore=False): # double-sweepで求める O(n)
u = self.dist.index(max(self.dist)) # 根から一番遠いものを根とし、そこから一番遠いものを見つける
dist_u = [-1] * self.n
dist_u[u] = 0
stack = [u]
parent_u = [None for _ in range(self.n)]
while stack:
v = stack.pop()
for child, cost in self.nexts[v]:
if dist_u[child] == -1:
dist_u[child] = dist_u[v] + cost
parent_u[child] = v
stack.append(child)
diameter = max(dist_u)
v = dist_u.index(diameter)
if restore:
path = [v]
while v != u:
v = parent_u[v]
path.append(v)
path.reverse() # [u,...,v]
return diameter, path
else:
return diameter, u, v
# ---------------------- #
n = int(eval(input()))
edges = []
for _ in range(n-1):
a, b, c = (int(x) for x in input().split())
a -= 1
b -= 1
edges.append((a, b, c))
q, k = (int(x) for x in input().split())
queries = [tuple(int(x) for x in input().split()) for _ in range(q)]
tree = Tree_with_edge_cost(n, edges)
tree.set_root(k-1)
for x, y in queries:
x -= 1
y -= 1
print((tree.dist[x] + tree.dist[y]))
| 75 | 74 | 2,013 | 2,457 |
class RadixHeap:
__slots__ = ["data", "last", "siz", "used"]
# (max_key - min_key) <= C
def __init__(self, N, C):
self.data = [[] for i in range(C.bit_length() + 1000)]
self.last = self.siz = 0
self.used = [0] * N
def push(self, x, key):
# assert self.last <= x
self.siz += 1
self.data[(x ^ self.last).bit_length()].append((x, key))
def pop(self):
data = self.data
used = self.used
# assert self.siz > 0
if not data[0]:
i = 1
while not data[i]:
i += 1
d = data[i]
new_last, new_key = min(d)
used[new_key] = 1
for val in d:
x, key = val
if used[key]:
self.siz -= 1
continue
data[(x ^ new_last).bit_length()].append(val)
self.last = new_last
data[i] = []
else:
new_last, new_key = data[0].pop()
used[new_key] = 1
self.siz -= 1
return new_last, new_key
def __len__(self):
return self.siz
def dijkstra(N, G, s):
que = RadixHeap(N, 10**9 + 1)
dist = [10**18] * N
dist[s] = 0
que.push(0, s)
while que:
cost, v = que.pop()
if dist[v] < cost:
continue
for w, c in G[v]:
if cost + c < dist[w]:
dist[w] = r = cost + c
que.push(r, w)
return dist
# ----------- #
n = int(eval(input()))
ABC = [tuple(int(x) for x in input().split()) for _ in range(n - 1)]
q, k = (int(x) for x in input().split())
queries = [tuple(int(x) for x in input().split()) for _ in range(q)]
G = [[] for _ in range(n)]
for a, b, c in ABC:
a -= 1
b -= 1
G[a].append((b, c))
G[b].append((a, c))
dist = dijkstra(n, G, k - 1)
for x, y in queries:
x -= 1
y -= 1
print((dist[x] + dist[y]))
|
class Tree_with_edge_cost:
def __init__(self, n, edge):
self.n = n
self.nexts = [[] for _ in range(n)]
for u, v, c in edge:
self.nexts[u].append((v, c))
self.nexts[v].append((u, c))
self.parent = [-1] * self.n
self.children = [[] for _ in range(self.n)]
self.cost = [0] * self.n
self.dist = [0] * self.n # 根からの距離
self.depth = [0] * self.n # 根からの深さ(cost=1での距離)
self.order = []
def set_root(self, root): # O(n)
self.order.append(root)
stack = [root]
while stack:
v = stack.pop()
for child, cost in self.nexts[v]:
if child == self.parent[v]:
continue
else:
self.parent[child] = v
self.children[v].append(child)
self.depth[child] = self.depth[v] + 1
self.dist[child] = self.dist[v] + cost
self.cost[child] = cost
self.order.append(child)
stack.append(child)
def get_diameter(self, restore=False): # double-sweepで求める O(n)
u = self.dist.index(max(self.dist)) # 根から一番遠いものを根とし、そこから一番遠いものを見つける
dist_u = [-1] * self.n
dist_u[u] = 0
stack = [u]
parent_u = [None for _ in range(self.n)]
while stack:
v = stack.pop()
for child, cost in self.nexts[v]:
if dist_u[child] == -1:
dist_u[child] = dist_u[v] + cost
parent_u[child] = v
stack.append(child)
diameter = max(dist_u)
v = dist_u.index(diameter)
if restore:
path = [v]
while v != u:
v = parent_u[v]
path.append(v)
path.reverse() # [u,...,v]
return diameter, path
else:
return diameter, u, v
# ---------------------- #
n = int(eval(input()))
edges = []
for _ in range(n - 1):
a, b, c = (int(x) for x in input().split())
a -= 1
b -= 1
edges.append((a, b, c))
q, k = (int(x) for x in input().split())
queries = [tuple(int(x) for x in input().split()) for _ in range(q)]
tree = Tree_with_edge_cost(n, edges)
tree.set_root(k - 1)
for x, y in queries:
x -= 1
y -= 1
print((tree.dist[x] + tree.dist[y]))
| false | 1.333333 |
[
"-class RadixHeap:",
"- __slots__ = [\"data\", \"last\", \"siz\", \"used\"]",
"- # (max_key - min_key) <= C",
"- def __init__(self, N, C):",
"- self.data = [[] for i in range(C.bit_length() + 1000)]",
"- self.last = self.siz = 0",
"- self.used = [0] * N",
"+class Tree_with_edge_cost:",
"+ def __init__(self, n, edge):",
"+ self.n = n",
"+ self.nexts = [[] for _ in range(n)]",
"+ for u, v, c in edge:",
"+ self.nexts[u].append((v, c))",
"+ self.nexts[v].append((u, c))",
"+ self.parent = [-1] * self.n",
"+ self.children = [[] for _ in range(self.n)]",
"+ self.cost = [0] * self.n",
"+ self.dist = [0] * self.n # 根からの距離",
"+ self.depth = [0] * self.n # 根からの深さ(cost=1での距離)",
"+ self.order = []",
"- def push(self, x, key):",
"- # assert self.last <= x",
"- self.siz += 1",
"- self.data[(x ^ self.last).bit_length()].append((x, key))",
"+ def set_root(self, root): # O(n)",
"+ self.order.append(root)",
"+ stack = [root]",
"+ while stack:",
"+ v = stack.pop()",
"+ for child, cost in self.nexts[v]:",
"+ if child == self.parent[v]:",
"+ continue",
"+ else:",
"+ self.parent[child] = v",
"+ self.children[v].append(child)",
"+ self.depth[child] = self.depth[v] + 1",
"+ self.dist[child] = self.dist[v] + cost",
"+ self.cost[child] = cost",
"+ self.order.append(child)",
"+ stack.append(child)",
"- def pop(self):",
"- data = self.data",
"- used = self.used",
"- # assert self.siz > 0",
"- if not data[0]:",
"- i = 1",
"- while not data[i]:",
"- i += 1",
"- d = data[i]",
"- new_last, new_key = min(d)",
"- used[new_key] = 1",
"- for val in d:",
"- x, key = val",
"- if used[key]:",
"- self.siz -= 1",
"- continue",
"- data[(x ^ new_last).bit_length()].append(val)",
"- self.last = new_last",
"- data[i] = []",
"+ def get_diameter(self, restore=False): # double-sweepで求める O(n)",
"+ u = self.dist.index(max(self.dist)) # 根から一番遠いものを根とし、そこから一番遠いものを見つける",
"+ dist_u = [-1] * self.n",
"+ dist_u[u] = 0",
"+ stack = [u]",
"+ parent_u = [None for _ in range(self.n)]",
"+ while stack:",
"+ v = stack.pop()",
"+ for child, cost in self.nexts[v]:",
"+ if dist_u[child] == -1:",
"+ dist_u[child] = dist_u[v] + cost",
"+ parent_u[child] = v",
"+ stack.append(child)",
"+ diameter = max(dist_u)",
"+ v = dist_u.index(diameter)",
"+ if restore:",
"+ path = [v]",
"+ while v != u:",
"+ v = parent_u[v]",
"+ path.append(v)",
"+ path.reverse() # [u,...,v]",
"+ return diameter, path",
"- new_last, new_key = data[0].pop()",
"- used[new_key] = 1",
"- self.siz -= 1",
"- return new_last, new_key",
"-",
"- def __len__(self):",
"- return self.siz",
"+ return diameter, u, v",
"-def dijkstra(N, G, s):",
"- que = RadixHeap(N, 10**9 + 1)",
"- dist = [10**18] * N",
"- dist[s] = 0",
"- que.push(0, s)",
"- while que:",
"- cost, v = que.pop()",
"- if dist[v] < cost:",
"- continue",
"- for w, c in G[v]:",
"- if cost + c < dist[w]:",
"- dist[w] = r = cost + c",
"- que.push(r, w)",
"- return dist",
"-",
"-",
"-ABC = [tuple(int(x) for x in input().split()) for _ in range(n - 1)]",
"+edges = []",
"+for _ in range(n - 1):",
"+ a, b, c = (int(x) for x in input().split())",
"+ a -= 1",
"+ b -= 1",
"+ edges.append((a, b, c))",
"-G = [[] for _ in range(n)]",
"-for a, b, c in ABC:",
"- a -= 1",
"- b -= 1",
"- G[a].append((b, c))",
"- G[b].append((a, c))",
"-dist = dijkstra(n, G, k - 1)",
"+tree = Tree_with_edge_cost(n, edges)",
"+tree.set_root(k - 1)",
"- print((dist[x] + dist[y]))",
"+ print((tree.dist[x] + tree.dist[y]))"
] | false | 0.113998 | 0.03535 | 3.224822 |
[
"s597761107",
"s643764387"
] |
u260036763
|
p03835
|
python
|
s145670509
|
s868954872
| 1,772 | 1,585 | 2,940 | 2,940 |
Accepted
|
Accepted
| 10.55 |
k, s = list(map(int, input().split()))
count = 0
for x in range(k+1):
for y in range(k+1):
z = s - x - y
if 0 <= z and z <= k:
count += 1
print(count)
|
k, s = list(map(int, input().split()))
count = 0
for x in range(k+1):
for y in range(k+1):
z = s - x - y
if 0 <= z <= k:
count += 1
print(count)
| 8 | 8 | 167 | 161 |
k, s = list(map(int, input().split()))
count = 0
for x in range(k + 1):
for y in range(k + 1):
z = s - x - y
if 0 <= z and z <= k:
count += 1
print(count)
|
k, s = list(map(int, input().split()))
count = 0
for x in range(k + 1):
for y in range(k + 1):
z = s - x - y
if 0 <= z <= k:
count += 1
print(count)
| false | 0 |
[
"- if 0 <= z and z <= k:",
"+ if 0 <= z <= k:"
] | false | 0.039205 | 0.084018 | 0.466624 |
[
"s145670509",
"s868954872"
] |
u905203728
|
p03329
|
python
|
s377846740
|
s743860928
| 1,270 | 1,174 | 3,828 | 3,828 |
Accepted
|
Accepted
| 7.56 |
n=int(eval(input()))
inf=float("inf")
DP=[inf]*(n+1)
DP[0]=0
for i in range(1,n+1):
DP[i]=DP[i-1]+1
for point in (6,9):
cnt=1
while point**cnt<=i:
DP[i]=min(DP[i-1]+1,DP[i-point**cnt]+1,DP[i])
cnt +=1
print((DP[n]))
|
n=int(eval(input()))
inf=float("inf")
DP=[inf]*(n+1)
DP[0]=0
for i in range(1,n+1):
DP[i]=DP[i-1]+1
for P in (6,9):
cnt=1
while P**cnt<=i:
DP[i]=min(DP[i-1]+1,DP[i-P**cnt]+1,DP[i])
cnt +=1
print((DP[n]))
| 14 | 14 | 282 | 258 |
n = int(eval(input()))
inf = float("inf")
DP = [inf] * (n + 1)
DP[0] = 0
for i in range(1, n + 1):
DP[i] = DP[i - 1] + 1
for point in (6, 9):
cnt = 1
while point**cnt <= i:
DP[i] = min(DP[i - 1] + 1, DP[i - point**cnt] + 1, DP[i])
cnt += 1
print((DP[n]))
|
n = int(eval(input()))
inf = float("inf")
DP = [inf] * (n + 1)
DP[0] = 0
for i in range(1, n + 1):
DP[i] = DP[i - 1] + 1
for P in (6, 9):
cnt = 1
while P**cnt <= i:
DP[i] = min(DP[i - 1] + 1, DP[i - P**cnt] + 1, DP[i])
cnt += 1
print((DP[n]))
| false | 0 |
[
"- for point in (6, 9):",
"+ for P in (6, 9):",
"- while point**cnt <= i:",
"- DP[i] = min(DP[i - 1] + 1, DP[i - point**cnt] + 1, DP[i])",
"+ while P**cnt <= i:",
"+ DP[i] = min(DP[i - 1] + 1, DP[i - P**cnt] + 1, DP[i])"
] | false | 0.006255 | 0.253693 | 0.024656 |
[
"s377846740",
"s743860928"
] |
u695811449
|
p02822
|
python
|
s676793457
|
s570596793
| 1,915 | 1,441 | 111,640 | 105,780 |
Accepted
|
Accepted
| 24.75 |
N=int(eval(input()))
E=[[] for i in range(N+1)]
for i in range(N-1):
x,y=list(map(int,input().split()))
E[x].append(y)
E[y].append(x)
mod=10**9+7
from collections import deque
Q=deque()
USE=[0]*(N+1)
Q.append(1)
H=[0]*(N+1)
H[1]=1
USE[1]=1
while Q:
x=Q.pop()
for to in E[x]:
if USE[to]==0:
USE[to]=1
H[to]=H[x]+1
Q.append(to)
EH=[(h,ind+1) for ind,h in enumerate(H[1:])]
EH.sort(reverse=True)
COME=[1]*(N+1)
USE=[0]*(N+1)
for h,ind in EH:
USE[ind]=1
for to in E[ind]:
if USE[to]==0:
COME[to]+=COME[ind]
ANS=0
POW2=[1]
for i in range(N+1):
POW2.append(POW2[-1]*2%mod)
for i in range(1,N+1):
SCORE=[]
for j in E[i]:
if COME[j]<COME[i]:
SCORE.append(COME[j])
if sum(SCORE)<N-1:
SCORE.append(N-sum(SCORE)-1)
AV=1
for s in SCORE:
AV+=POW2[s]-1
ANS+=POW2[N-1]-AV
#print(SCORE,AV)
print(((ANS*pow(POW2[N],mod-2,mod))%mod))
|
import sys
input = sys.stdin.readline
N=int(eval(input()))
E=[[] for i in range(N+1)]
for i in range(N-1):
x,y=list(map(int,input().split()))
E[x].append(y)
E[y].append(x)
mod=10**9+7
from collections import deque
Q=deque()
USE=[0]*(N+1)
Q.append(1)
H=[0]*(N+1)
H[1]=1
USE[1]=1
while Q:
x=Q.pop()
for to in E[x]:
if USE[to]==0:
USE[to]=1
H[to]=H[x]+1
Q.append(to)
EH=[(h,ind+1) for ind,h in enumerate(H[1:])]
EH.sort(reverse=True)
COME=[1]*(N+1)
USE=[0]*(N+1)
for h,ind in EH:
USE[ind]=1
for to in E[ind]:
if USE[to]==0:
COME[to]+=COME[ind]
ANS=0
POW2=[1]
for i in range(N+1):
POW2.append(POW2[-1]*2%mod)
for i in range(1,N+1):
SCORE=[]
for j in E[i]:
if COME[j]<COME[i]:
SCORE.append(COME[j])
if sum(SCORE)<N-1:
SCORE.append(N-sum(SCORE)-1)
AV=1
for s in SCORE:
AV+=POW2[s]-1
ANS+=POW2[N-1]-AV
#print(SCORE,AV)
print(((ANS*pow(POW2[N],mod-2,mod))%mod))
| 64 | 67 | 1,041 | 1,083 |
N = int(eval(input()))
E = [[] for i in range(N + 1)]
for i in range(N - 1):
x, y = list(map(int, input().split()))
E[x].append(y)
E[y].append(x)
mod = 10**9 + 7
from collections import deque
Q = deque()
USE = [0] * (N + 1)
Q.append(1)
H = [0] * (N + 1)
H[1] = 1
USE[1] = 1
while Q:
x = Q.pop()
for to in E[x]:
if USE[to] == 0:
USE[to] = 1
H[to] = H[x] + 1
Q.append(to)
EH = [(h, ind + 1) for ind, h in enumerate(H[1:])]
EH.sort(reverse=True)
COME = [1] * (N + 1)
USE = [0] * (N + 1)
for h, ind in EH:
USE[ind] = 1
for to in E[ind]:
if USE[to] == 0:
COME[to] += COME[ind]
ANS = 0
POW2 = [1]
for i in range(N + 1):
POW2.append(POW2[-1] * 2 % mod)
for i in range(1, N + 1):
SCORE = []
for j in E[i]:
if COME[j] < COME[i]:
SCORE.append(COME[j])
if sum(SCORE) < N - 1:
SCORE.append(N - sum(SCORE) - 1)
AV = 1
for s in SCORE:
AV += POW2[s] - 1
ANS += POW2[N - 1] - AV
# print(SCORE,AV)
print(((ANS * pow(POW2[N], mod - 2, mod)) % mod))
|
import sys
input = sys.stdin.readline
N = int(eval(input()))
E = [[] for i in range(N + 1)]
for i in range(N - 1):
x, y = list(map(int, input().split()))
E[x].append(y)
E[y].append(x)
mod = 10**9 + 7
from collections import deque
Q = deque()
USE = [0] * (N + 1)
Q.append(1)
H = [0] * (N + 1)
H[1] = 1
USE[1] = 1
while Q:
x = Q.pop()
for to in E[x]:
if USE[to] == 0:
USE[to] = 1
H[to] = H[x] + 1
Q.append(to)
EH = [(h, ind + 1) for ind, h in enumerate(H[1:])]
EH.sort(reverse=True)
COME = [1] * (N + 1)
USE = [0] * (N + 1)
for h, ind in EH:
USE[ind] = 1
for to in E[ind]:
if USE[to] == 0:
COME[to] += COME[ind]
ANS = 0
POW2 = [1]
for i in range(N + 1):
POW2.append(POW2[-1] * 2 % mod)
for i in range(1, N + 1):
SCORE = []
for j in E[i]:
if COME[j] < COME[i]:
SCORE.append(COME[j])
if sum(SCORE) < N - 1:
SCORE.append(N - sum(SCORE) - 1)
AV = 1
for s in SCORE:
AV += POW2[s] - 1
ANS += POW2[N - 1] - AV
# print(SCORE,AV)
print(((ANS * pow(POW2[N], mod - 2, mod)) % mod))
| false | 4.477612 |
[
"+import sys",
"+",
"+input = sys.stdin.readline"
] | false | 0.158422 | 0.042066 | 3.766031 |
[
"s676793457",
"s570596793"
] |
u716530146
|
p03037
|
python
|
s674746995
|
s516330311
| 609 | 311 | 60,120 | 56,284 |
Accepted
|
Accepted
| 48.93 |
n,m=list(map(int,input().split()))
data=[list(map(int,input().split())) for i in range(m)]
import sys
input = lambda: sys.stdin.readline()[:-1]
l,r=0,10**6
for i,j in data:
l=max(l,i)
r=min(r,j)
print((max(0,r-l+1)))
|
#!/usr/bin/env python3
import sys
input = lambda: sys.stdin.readline()[:-1]
sys.setrecursionlimit(10**8)
inf = float('inf')
mod = 10**9+7
n, m = list(map(int, input().split()))
data = [list(map(int, input().split())) for i in range(m)]
l, r = 0, 10**6
for i, j in data:
l = max(l, i)
r = min(r, j)
print((max(0, r-l+1)))
| 10 | 20 | 221 | 341 |
n, m = list(map(int, input().split()))
data = [list(map(int, input().split())) for i in range(m)]
import sys
input = lambda: sys.stdin.readline()[:-1]
l, r = 0, 10**6
for i, j in data:
l = max(l, i)
r = min(r, j)
print((max(0, r - l + 1)))
|
#!/usr/bin/env python3
import sys
input = lambda: sys.stdin.readline()[:-1]
sys.setrecursionlimit(10**8)
inf = float("inf")
mod = 10**9 + 7
n, m = list(map(int, input().split()))
data = [list(map(int, input().split())) for i in range(m)]
l, r = 0, 10**6
for i, j in data:
l = max(l, i)
r = min(r, j)
print((max(0, r - l + 1)))
| false | 50 |
[
"-n, m = list(map(int, input().split()))",
"-data = [list(map(int, input().split())) for i in range(m)]",
"+#!/usr/bin/env python3",
"+sys.setrecursionlimit(10**8)",
"+inf = float(\"inf\")",
"+mod = 10**9 + 7",
"+n, m = list(map(int, input().split()))",
"+data = [list(map(int, input().split())) for i in range(m)]"
] | false | 0.045625 | 0.038479 | 1.185721 |
[
"s674746995",
"s516330311"
] |
u550943777
|
p03127
|
python
|
s159704937
|
s553211631
| 117 | 75 | 15,020 | 14,224 |
Accepted
|
Accepted
| 35.9 |
def gcd(a,b):
if a < b:
return gcd(b,a)
else:
if a%b == 0:
return b
else:
return gcd(b,a%b)
N = int(eval(input()))
src = sorted(list(map(int,input().split())))
ans = src[0]
for i in range(1,N)[::-1]:
ans = gcd(ans,src[i])
print(ans)
|
def Gcd(a,b):
if a < b:
return Gcd(b,a)
else:
if a%b:
return Gcd(b,a%b)
else:
return b
N = int(eval(input()))
arr = list(map(int,input().split()))
gcd = arr[0]
for i in arr:
gcd = Gcd(gcd,i)
print(gcd)
| 14 | 15 | 299 | 270 |
def gcd(a, b):
if a < b:
return gcd(b, a)
else:
if a % b == 0:
return b
else:
return gcd(b, a % b)
N = int(eval(input()))
src = sorted(list(map(int, input().split())))
ans = src[0]
for i in range(1, N)[::-1]:
ans = gcd(ans, src[i])
print(ans)
|
def Gcd(a, b):
if a < b:
return Gcd(b, a)
else:
if a % b:
return Gcd(b, a % b)
else:
return b
N = int(eval(input()))
arr = list(map(int, input().split()))
gcd = arr[0]
for i in arr:
gcd = Gcd(gcd, i)
print(gcd)
| false | 6.666667 |
[
"-def gcd(a, b):",
"+def Gcd(a, b):",
"- return gcd(b, a)",
"+ return Gcd(b, a)",
"- if a % b == 0:",
"+ if a % b:",
"+ return Gcd(b, a % b)",
"+ else:",
"- else:",
"- return gcd(b, a % b)",
"-src = sorted(list(map(int, input().split())))",
"-ans = src[0]",
"-for i in range(1, N)[::-1]:",
"- ans = gcd(ans, src[i])",
"-print(ans)",
"+arr = list(map(int, input().split()))",
"+gcd = arr[0]",
"+for i in arr:",
"+ gcd = Gcd(gcd, i)",
"+print(gcd)"
] | false | 0.037111 | 0.068324 | 0.543162 |
[
"s159704937",
"s553211631"
] |
u077291787
|
p03785
|
python
|
s776880799
|
s403699559
| 103 | 86 | 14,236 | 14,052 |
Accepted
|
Accepted
| 16.5 |
# AGC011A - Airport Bus
import sys
input = sys.stdin.readline
def main():
N, C, K = tuple(map(int, input().rstrip().split()))
T = sorted(map(int, [input().rstrip() for _ in range(N)]))
ans, cur, cnt = 0, T[0] + K, 0
for i in T:
if i > cur or cnt == C: # need a new bus
cur = i + K
cnt = 1
ans += 1
else: # ride on the current bus
cnt += 1
print((ans + 1))
if __name__ == "__main__":
main()
|
# AGC011A - Airport Bus
def main():
N, C, K, *T = list(map(int, open(0).read().split()))
T.sort()
ans, cur, cnt = 0, T[0] + K, 0
for i in T:
if i > cur or cnt == C: # need a new bus
cur = i + K
cnt = 1
ans += 1
else: # ride on the current one
cnt += 1
print((ans + 1))
if __name__ == "__main__":
main()
| 20 | 17 | 499 | 402 |
# AGC011A - Airport Bus
import sys
input = sys.stdin.readline
def main():
N, C, K = tuple(map(int, input().rstrip().split()))
T = sorted(map(int, [input().rstrip() for _ in range(N)]))
ans, cur, cnt = 0, T[0] + K, 0
for i in T:
if i > cur or cnt == C: # need a new bus
cur = i + K
cnt = 1
ans += 1
else: # ride on the current bus
cnt += 1
print((ans + 1))
if __name__ == "__main__":
main()
|
# AGC011A - Airport Bus
def main():
N, C, K, *T = list(map(int, open(0).read().split()))
T.sort()
ans, cur, cnt = 0, T[0] + K, 0
for i in T:
if i > cur or cnt == C: # need a new bus
cur = i + K
cnt = 1
ans += 1
else: # ride on the current one
cnt += 1
print((ans + 1))
if __name__ == "__main__":
main()
| false | 15 |
[
"-import sys",
"-",
"-input = sys.stdin.readline",
"-",
"-",
"- N, C, K = tuple(map(int, input().rstrip().split()))",
"- T = sorted(map(int, [input().rstrip() for _ in range(N)]))",
"+ N, C, K, *T = list(map(int, open(0).read().split()))",
"+ T.sort()",
"- else: # ride on the current bus",
"+ else: # ride on the current one"
] | false | 0.040024 | 0.043889 | 0.911932 |
[
"s776880799",
"s403699559"
] |
u708255304
|
p02642
|
python
|
s362779001
|
s139622865
| 700 | 218 | 51,324 | 120,872 |
Accepted
|
Accepted
| 68.86 |
from collections import Counter
N = int(eval(input()))
A = list(map(int, input().split()))
A.sort()
count_of_a = Counter(A)
# すでに出現した倍数の場合はアウト
ans = 0
max_A = max(A)
dp = [True] * (max_A+1)
happpend = set()
for a in A:
if count_of_a[a] >= 2:
# 複数出現するとしても，初めての要素の場合は処理を行う
if a in happpend:
continue
x = a*2
while x <= max_A:
dp[x] = False
x += a
happpend.add(a)
else:
if dp[a]:
ans += 1
x = a*2
while x <= max_A:
dp[x] = False
x += a
happpend.add(a)
print(ans)
|
from collections import Counter
N = int(eval(input()))
A = list(map(int, input().split()))
A.sort()
count_of_a = Counter(A)
# すでに出現した倍数の場合はアウト
ans = 0
max_A = max(A)
dp = [True] * (max_A+1)
happpend = set()
for a in A:
if count_of_a[a] >= 2:
# 複数出現するとしても，初めての要素の場合は処理を行う
if a in happpend:
continue
x = a*2
while x <= max_A:
dp[x] = False
x += a
happpend.add(a)
else:
if dp[a]:
ans += 1
x = a*2
while x <= max_A:
dp[x] = False
x += a
print(ans)
| 29 | 28 | 634 | 609 |
from collections import Counter
N = int(eval(input()))
A = list(map(int, input().split()))
A.sort()
count_of_a = Counter(A)
# すでに出現した倍数の場合はアウト
ans = 0
max_A = max(A)
dp = [True] * (max_A + 1)
happpend = set()
for a in A:
if count_of_a[a] >= 2:
# 複数出現するとしても，初めての要素の場合は処理を行う
if a in happpend:
continue
x = a * 2
while x <= max_A:
dp[x] = False
x += a
happpend.add(a)
else:
if dp[a]:
ans += 1
x = a * 2
while x <= max_A:
dp[x] = False
x += a
happpend.add(a)
print(ans)
|
from collections import Counter
N = int(eval(input()))
A = list(map(int, input().split()))
A.sort()
count_of_a = Counter(A)
# すでに出現した倍数の場合はアウト
ans = 0
max_A = max(A)
dp = [True] * (max_A + 1)
happpend = set()
for a in A:
if count_of_a[a] >= 2:
# 複数出現するとしても，初めての要素の場合は処理を行う
if a in happpend:
continue
x = a * 2
while x <= max_A:
dp[x] = False
x += a
happpend.add(a)
else:
if dp[a]:
ans += 1
x = a * 2
while x <= max_A:
dp[x] = False
x += a
print(ans)
| false | 3.448276 |
[
"- happpend.add(a)"
] | false | 0.073774 | 0.069436 | 1.062482 |
[
"s362779001",
"s139622865"
] |
u064408584
|
p03805
|
python
|
s143487824
|
s874252968
| 125 | 78 | 4,988 | 3,064 |
Accepted
|
Accepted
| 37.6 |
n,m=list(map(int, input().split()))
q=[]
for i in range(m):
a,b=list(map(int, input().split()))
q.append([a,b])
q.append([b,a])
p=[[1]]
count=0
route=set()
while len(p)!=0:
p1=p.pop()
for i,j in q:
#print(i,j)
if i == p1[-1]:
if j not in p1:
p.append(p1+[j])
if len(p1)==n: count+=1
route |= {tuple(p1)}
#print(p,p1)
print(count)
|
n,m=list(map(int, input().split()))
q=[]
for i in range(m):
a,b=list(map(int, input().split()))
q+=[[a,b],[b,a]]
p=[[1]]
count=0
while p:
p1=p.pop()
if len(p1)==n:count+=1
else:
for i,j in q:
if i == p1[-1] and j not in p1:
p.append(p1+[j])
#print(p1,p)
print(count)
| 21 | 16 | 414 | 329 |
n, m = list(map(int, input().split()))
q = []
for i in range(m):
a, b = list(map(int, input().split()))
q.append([a, b])
q.append([b, a])
p = [[1]]
count = 0
route = set()
while len(p) != 0:
p1 = p.pop()
for i, j in q:
# print(i,j)
if i == p1[-1]:
if j not in p1:
p.append(p1 + [j])
if len(p1) == n:
count += 1
route |= {tuple(p1)}
# print(p,p1)
print(count)
|
n, m = list(map(int, input().split()))
q = []
for i in range(m):
a, b = list(map(int, input().split()))
q += [[a, b], [b, a]]
p = [[1]]
count = 0
while p:
p1 = p.pop()
if len(p1) == n:
count += 1
else:
for i, j in q:
if i == p1[-1] and j not in p1:
p.append(p1 + [j])
# print(p1,p)
print(count)
| false | 23.809524 |
[
"- q.append([a, b])",
"- q.append([b, a])",
"+ q += [[a, b], [b, a]]",
"-route = set()",
"-while len(p) != 0:",
"+while p:",
"- for i, j in q:",
"- # print(i,j)",
"- if i == p1[-1]:",
"- if j not in p1:",
"- p.append(p1 + [j])",
"- route |= {tuple(p1)}",
"- # print(p,p1)",
"+ else:",
"+ for i, j in q:",
"+ if i == p1[-1] and j not in p1:",
"+ p.append(p1 + [j])",
"+ # print(p1,p)"
] | false | 0.039696 | 0.044279 | 0.896495 |
[
"s143487824",
"s874252968"
] |
u796942881
|
p03828
|
python
|
s319878201
|
s438629863
| 24 | 17 | 3,572 | 3,064 |
Accepted
|
Accepted
| 29.17 |
from functools import reduce
INF = int(1e9+7)
def primeFactor(n, pf):
# 素因数分解
if n == 1:
return
f = 2
while (f * f <= n):
if (n % f == 0):
pf[f] += 1
n = n // f
else:
f += 1
pf[n] += 1
def main():
N = int(eval(input()))
pf = [0] * (N + 1)
for i in range(1, N + 1):
primeFactor(i, pf)
print((reduce(lambda x, y : x * (y + 1) % INF, pf, 1)))
return
main()
|
INF = int(1e9+7)
def primeNumber(n, pn):
# Sieve of Eratosthenes
b = [True] * (n + 1)
for i in range(2, n + 1):
if b[i]:
pn.append(i)
for j in range(i, n + 1, i):
b[j] = False
return
def main():
N = int(eval(input()))
pn = []
primeNumber(N, pn)
ans = 1
for p in pn:
cnt = 0
cum = p
while cum <= N:
cnt += N // cum
cum *= p
ans = ans * (cnt + 1) % INF
print(ans)
main()
| 28 | 30 | 487 | 542 |
from functools import reduce
INF = int(1e9 + 7)
def primeFactor(n, pf):
# 素因数分解
if n == 1:
return
f = 2
while f * f <= n:
if n % f == 0:
pf[f] += 1
n = n // f
else:
f += 1
pf[n] += 1
def main():
N = int(eval(input()))
pf = [0] * (N + 1)
for i in range(1, N + 1):
primeFactor(i, pf)
print((reduce(lambda x, y: x * (y + 1) % INF, pf, 1)))
return
main()
|
INF = int(1e9 + 7)
def primeNumber(n, pn):
# Sieve of Eratosthenes
b = [True] * (n + 1)
for i in range(2, n + 1):
if b[i]:
pn.append(i)
for j in range(i, n + 1, i):
b[j] = False
return
def main():
N = int(eval(input()))
pn = []
primeNumber(N, pn)
ans = 1
for p in pn:
cnt = 0
cum = p
while cum <= N:
cnt += N // cum
cum *= p
ans = ans * (cnt + 1) % INF
print(ans)
main()
| false | 6.666667 |
[
"-from functools import reduce",
"-",
"-def primeFactor(n, pf):",
"- # 素因数分解",
"- if n == 1:",
"- return",
"- f = 2",
"- while f * f <= n:",
"- if n % f == 0:",
"- pf[f] += 1",
"- n = n // f",
"- else:",
"- f += 1",
"- pf[n] += 1",
"+def primeNumber(n, pn):",
"+ # Sieve of Eratosthenes",
"+ b = [True] * (n + 1)",
"+ for i in range(2, n + 1):",
"+ if b[i]:",
"+ pn.append(i)",
"+ for j in range(i, n + 1, i):",
"+ b[j] = False",
"+ return",
"- pf = [0] * (N + 1)",
"- for i in range(1, N + 1):",
"- primeFactor(i, pf)",
"- print((reduce(lambda x, y: x * (y + 1) % INF, pf, 1)))",
"- return",
"+ pn = []",
"+ primeNumber(N, pn)",
"+ ans = 1",
"+ for p in pn:",
"+ cnt = 0",
"+ cum = p",
"+ while cum <= N:",
"+ cnt += N // cum",
"+ cum *= p",
"+ ans = ans * (cnt + 1) % INF",
"+ print(ans)"
] | false | 0.03826 | 0.037469 | 1.021108 |
[
"s319878201",
"s438629863"
] |
u729133443
|
p03135
|
python
|
s853514344
|
s015616802
| 164 | 27 | 38,484 | 9,032 |
Accepted
|
Accepted
| 83.54 |
print((eval(input().replace(' ','/'))))
|
print((eval(input().replace(*' /'))))
| 1 | 1 | 37 | 35 |
print((eval(input().replace(" ", "/"))))
|
print((eval(input().replace(*" /"))))
| false | 0 |
[
"-print((eval(input().replace(\" \", \"/\"))))",
"+print((eval(input().replace(*\" /\"))))"
] | false | 0.05177 | 0.05231 | 0.989671 |
[
"s853514344",
"s015616802"
] |
u488401358
|
p02763
|
python
|
s601135063
|
s616553529
| 1,099 | 244 | 148,168 | 118,944 |
Accepted
|
Accepted
| 77.8 |
class SegmentTree():
def __init__(self,n,ide_ele,merge_func):
self.n=n
self.ide_ele=ide_ele
self.merge_func=merge_func
self.val=[0 for i in range(1<<n)]
self.merge=[0 for i in range(1<<n)]
def update(self,id,x):
stack=[]
pos=1<<(self.n-1)
while pos-1!=id:
stack.append(pos)
if pos-1>id:
pos-=((pos)&(-pos))//2
else:
pos+=((pos)&(-pos))//2
stack.append(pos)
self.val[pos-1]=x
for pos in stack[::-1]:
if pos%2:
self.merge[pos-1]=self.val[pos-1]
else:
gap=((pos)&(-pos))//2
r=pos+gap
l=pos-gap
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[r-1],self.merge[l-1])
def cnt(self,k):
lsb=(k)&(-k)
return (lsb<<1)-1
def lower_kth_merge(self,nd,k):
res=self.ide_ele
id=nd
if k==-1:
return res
while True:
if not id%2:
gap=((id)&(-id))//2
l=id-gap
r=id+gap
cnt=self.cnt(l)
if cnt<k:
k-=cnt+1
res=self.merge_func(res,self.val[id-1],self.merge[l-1])
id=r
elif cnt==k:
res=self.merge_func(res,self.val[id-1],self.merge[l-1])
return res
else:
id=l
else:
res=self.merge_func(res,self.val[id-1])
return res
def upper_kth_merge(self,nd,k):
res=self.ide_ele
id=nd
if k==-1:
return res
while True:
if not id%2:
gap=((id)&(-id))//2
l=id-gap
r=id+gap
cnt=self.cnt(r)
if cnt<k:
k-=cnt+1
res=self.merge_func(res,self.val[id-1],self.merge[r-1])
id=l
elif cnt==k:
res=self.merge_func(res,self.val[id-1],self.merge[r-1])
return res
else:
id=r
else:
res=self.merge_func(res,self.val[id-1])
return res
def query(self,l,r):
id=1<<(self.n-1)
while True:
if id-1<l:
id+=((id)&(-id))//2
elif id-1>r:
id-=((id)&(-id))//2
else:
res=self.val[id-1]
if id%2:
return res
gap=((id)&(-id))//2
L,R=id-gap,id+gap
#print(l,r,id,L,R)
left=self.upper_kth_merge(L,id-1-l-1)
right=self.lower_kth_merge(R,r-id)
return self.merge_func(res,left,right)
ide_ele=0
def seg_func(*args):
res=ide_ele
for val in args:
res|=val
return res
def popcount(x):
x = x - ((x >> 1) & 0x55555555)
x = (x & 0x33333333) + ((x >> 2) & 0x33333333)
x = (x + (x >> 4)) & 0x0f0f0f0f
x = x + (x >> 8)
x = x + (x >> 16)
return x & 0x0000007f
import sys
input=sys.stdin.readline
N=int(eval(input()))
S=input().rstrip()
test=SegmentTree(19,ide_ele,seg_func)
for i in range(N):
val=ord(S[i])-97
test.update(i,1<<val)
for _ in range(int(eval(input()))):
t,l,r=input().split()
t,l=int(t),int(l)
if t==1:
val=ord(r)-97
test.update(l-1,1<<val)
else:
r=int(r)
res=test.query(l-1,r-1)
print((popcount(res)))
|
def segfunc(x,y):
return x|y
def init(init_val):
#set_val
for i in range(n):
seg[i+num-1]=init_val[i]
#built
for i in range(num-2,-1,-1) :
seg[i]=segfunc(seg[2*i+1],seg[2*i+2])
def update(k,x):
k += num-1
seg[k] = x
while k:
k = (k-1)//2
seg[k] = segfunc(seg[k*2+1],seg[k*2+2])
def query(p,q):
if q<=p:
return ide_ele
p += num-1
q += num-2
res=ide_ele
while q-p>1:
if p&1 == 0:
res = segfunc(res,seg[p])
if q&1 == 1:
res = segfunc(res,seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = segfunc(res,seg[p])
else:
res = segfunc(segfunc(res,seg[p]),seg[q])
return res
#####単位元######
ide_ele = 0
#num:n以上の最小の2のべき乗
n=int(eval(input()))
S=eval(input())
Q=int(eval(input()))
num =2**(n-1).bit_length()
seg=[ide_ele]*2*num
alphabetlist=['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z']
alphabet={key:alphabetlist.index(key) for key in alphabetlist}
data=[0 for i in range(0,n)]
for i in range(0,n):
data[i]=2**(alphabet[S[i]])
init(data)
ans=[]
for i in range(0,Q):
q,a,b=input().split()
if q=='1':
update(int(a)-1,2**(alphabet[b]))
else:
a=int(a)
b=int(b)
ans.append(query(a-1,b))
for i in range(len(ans)):
x=ans[i]
print((bin(x).count('1')))
| 137 | 71 | 3,777 | 1,501 |
class SegmentTree:
def __init__(self, n, ide_ele, merge_func):
self.n = n
self.ide_ele = ide_ele
self.merge_func = merge_func
self.val = [0 for i in range(1 << n)]
self.merge = [0 for i in range(1 << n)]
def update(self, id, x):
stack = []
pos = 1 << (self.n - 1)
while pos - 1 != id:
stack.append(pos)
if pos - 1 > id:
pos -= ((pos) & (-pos)) // 2
else:
pos += ((pos) & (-pos)) // 2
stack.append(pos)
self.val[pos - 1] = x
for pos in stack[::-1]:
if pos % 2:
self.merge[pos - 1] = self.val[pos - 1]
else:
gap = ((pos) & (-pos)) // 2
r = pos + gap
l = pos - gap
self.merge[pos - 1] = self.merge_func(
self.val[pos - 1], self.merge[r - 1], self.merge[l - 1]
)
def cnt(self, k):
lsb = (k) & (-k)
return (lsb << 1) - 1
def lower_kth_merge(self, nd, k):
res = self.ide_ele
id = nd
if k == -1:
return res
while True:
if not id % 2:
gap = ((id) & (-id)) // 2
l = id - gap
r = id + gap
cnt = self.cnt(l)
if cnt < k:
k -= cnt + 1
res = self.merge_func(res, self.val[id - 1], self.merge[l - 1])
id = r
elif cnt == k:
res = self.merge_func(res, self.val[id - 1], self.merge[l - 1])
return res
else:
id = l
else:
res = self.merge_func(res, self.val[id - 1])
return res
def upper_kth_merge(self, nd, k):
res = self.ide_ele
id = nd
if k == -1:
return res
while True:
if not id % 2:
gap = ((id) & (-id)) // 2
l = id - gap
r = id + gap
cnt = self.cnt(r)
if cnt < k:
k -= cnt + 1
res = self.merge_func(res, self.val[id - 1], self.merge[r - 1])
id = l
elif cnt == k:
res = self.merge_func(res, self.val[id - 1], self.merge[r - 1])
return res
else:
id = r
else:
res = self.merge_func(res, self.val[id - 1])
return res
def query(self, l, r):
id = 1 << (self.n - 1)
while True:
if id - 1 < l:
id += ((id) & (-id)) // 2
elif id - 1 > r:
id -= ((id) & (-id)) // 2
else:
res = self.val[id - 1]
if id % 2:
return res
gap = ((id) & (-id)) // 2
L, R = id - gap, id + gap
# print(l,r,id,L,R)
left = self.upper_kth_merge(L, id - 1 - l - 1)
right = self.lower_kth_merge(R, r - id)
return self.merge_func(res, left, right)
ide_ele = 0
def seg_func(*args):
res = ide_ele
for val in args:
res |= val
return res
def popcount(x):
x = x - ((x >> 1) & 0x55555555)
x = (x & 0x33333333) + ((x >> 2) & 0x33333333)
x = (x + (x >> 4)) & 0x0F0F0F0F
x = x + (x >> 8)
x = x + (x >> 16)
return x & 0x0000007F
import sys
input = sys.stdin.readline
N = int(eval(input()))
S = input().rstrip()
test = SegmentTree(19, ide_ele, seg_func)
for i in range(N):
val = ord(S[i]) - 97
test.update(i, 1 << val)
for _ in range(int(eval(input()))):
t, l, r = input().split()
t, l = int(t), int(l)
if t == 1:
val = ord(r) - 97
test.update(l - 1, 1 << val)
else:
r = int(r)
res = test.query(l - 1, r - 1)
print((popcount(res)))
|
def segfunc(x, y):
return x | y
def init(init_val):
# set_val
for i in range(n):
seg[i + num - 1] = init_val[i]
# built
for i in range(num - 2, -1, -1):
seg[i] = segfunc(seg[2 * i + 1], seg[2 * i + 2])
def update(k, x):
k += num - 1
seg[k] = x
while k:
k = (k - 1) // 2
seg[k] = segfunc(seg[k * 2 + 1], seg[k * 2 + 2])
def query(p, q):
if q <= p:
return ide_ele
p += num - 1
q += num - 2
res = ide_ele
while q - p > 1:
if p & 1 == 0:
res = segfunc(res, seg[p])
if q & 1 == 1:
res = segfunc(res, seg[q])
q -= 1
p = p // 2
q = (q - 1) // 2
if p == q:
res = segfunc(res, seg[p])
else:
res = segfunc(segfunc(res, seg[p]), seg[q])
return res
#####単位元######
ide_ele = 0
# num:n以上の最小の2のべき乗
n = int(eval(input()))
S = eval(input())
Q = int(eval(input()))
num = 2 ** (n - 1).bit_length()
seg = [ide_ele] * 2 * num
alphabetlist = [
"a",
"b",
"c",
"d",
"e",
"f",
"g",
"h",
"i",
"j",
"k",
"l",
"m",
"n",
"o",
"p",
"q",
"r",
"s",
"t",
"u",
"v",
"w",
"x",
"y",
"z",
]
alphabet = {key: alphabetlist.index(key) for key in alphabetlist}
data = [0 for i in range(0, n)]
for i in range(0, n):
data[i] = 2 ** (alphabet[S[i]])
init(data)
ans = []
for i in range(0, Q):
q, a, b = input().split()
if q == "1":
update(int(a) - 1, 2 ** (alphabet[b]))
else:
a = int(a)
b = int(b)
ans.append(query(a - 1, b))
for i in range(len(ans)):
x = ans[i]
print((bin(x).count("1")))
| false | 48.175182 |
[
"-class SegmentTree:",
"- def __init__(self, n, ide_ele, merge_func):",
"- self.n = n",
"- self.ide_ele = ide_ele",
"- self.merge_func = merge_func",
"- self.val = [0 for i in range(1 << n)]",
"- self.merge = [0 for i in range(1 << n)]",
"-",
"- def update(self, id, x):",
"- stack = []",
"- pos = 1 << (self.n - 1)",
"- while pos - 1 != id:",
"- stack.append(pos)",
"- if pos - 1 > id:",
"- pos -= ((pos) & (-pos)) // 2",
"- else:",
"- pos += ((pos) & (-pos)) // 2",
"- stack.append(pos)",
"- self.val[pos - 1] = x",
"- for pos in stack[::-1]:",
"- if pos % 2:",
"- self.merge[pos - 1] = self.val[pos - 1]",
"- else:",
"- gap = ((pos) & (-pos)) // 2",
"- r = pos + gap",
"- l = pos - gap",
"- self.merge[pos - 1] = self.merge_func(",
"- self.val[pos - 1], self.merge[r - 1], self.merge[l - 1]",
"- )",
"-",
"- def cnt(self, k):",
"- lsb = (k) & (-k)",
"- return (lsb << 1) - 1",
"-",
"- def lower_kth_merge(self, nd, k):",
"- res = self.ide_ele",
"- id = nd",
"- if k == -1:",
"- return res",
"- while True:",
"- if not id % 2:",
"- gap = ((id) & (-id)) // 2",
"- l = id - gap",
"- r = id + gap",
"- cnt = self.cnt(l)",
"- if cnt < k:",
"- k -= cnt + 1",
"- res = self.merge_func(res, self.val[id - 1], self.merge[l - 1])",
"- id = r",
"- elif cnt == k:",
"- res = self.merge_func(res, self.val[id - 1], self.merge[l - 1])",
"- return res",
"- else:",
"- id = l",
"- else:",
"- res = self.merge_func(res, self.val[id - 1])",
"- return res",
"-",
"- def upper_kth_merge(self, nd, k):",
"- res = self.ide_ele",
"- id = nd",
"- if k == -1:",
"- return res",
"- while True:",
"- if not id % 2:",
"- gap = ((id) & (-id)) // 2",
"- l = id - gap",
"- r = id + gap",
"- cnt = self.cnt(r)",
"- if cnt < k:",
"- k -= cnt + 1",
"- res = self.merge_func(res, self.val[id - 1], self.merge[r - 1])",
"- id = l",
"- elif cnt == k:",
"- res = self.merge_func(res, self.val[id - 1], self.merge[r - 1])",
"- return res",
"- else:",
"- id = r",
"- else:",
"- res = self.merge_func(res, self.val[id - 1])",
"- return res",
"-",
"- def query(self, l, r):",
"- id = 1 << (self.n - 1)",
"- while True:",
"- if id - 1 < l:",
"- id += ((id) & (-id)) // 2",
"- elif id - 1 > r:",
"- id -= ((id) & (-id)) // 2",
"- else:",
"- res = self.val[id - 1]",
"- if id % 2:",
"- return res",
"- gap = ((id) & (-id)) // 2",
"- L, R = id - gap, id + gap",
"- # print(l,r,id,L,R)",
"- left = self.upper_kth_merge(L, id - 1 - l - 1)",
"- right = self.lower_kth_merge(R, r - id)",
"- return self.merge_func(res, left, right)",
"+def segfunc(x, y):",
"+ return x | y",
"-ide_ele = 0",
"+def init(init_val):",
"+ # set_val",
"+ for i in range(n):",
"+ seg[i + num - 1] = init_val[i]",
"+ # built",
"+ for i in range(num - 2, -1, -1):",
"+ seg[i] = segfunc(seg[2 * i + 1], seg[2 * i + 2])",
"-def seg_func(*args):",
"+def update(k, x):",
"+ k += num - 1",
"+ seg[k] = x",
"+ while k:",
"+ k = (k - 1) // 2",
"+ seg[k] = segfunc(seg[k * 2 + 1], seg[k * 2 + 2])",
"+",
"+",
"+def query(p, q):",
"+ if q <= p:",
"+ return ide_ele",
"+ p += num - 1",
"+ q += num - 2",
"- for val in args:",
"- res |= val",
"+ while q - p > 1:",
"+ if p & 1 == 0:",
"+ res = segfunc(res, seg[p])",
"+ if q & 1 == 1:",
"+ res = segfunc(res, seg[q])",
"+ q -= 1",
"+ p = p // 2",
"+ q = (q - 1) // 2",
"+ if p == q:",
"+ res = segfunc(res, seg[p])",
"+ else:",
"+ res = segfunc(segfunc(res, seg[p]), seg[q])",
"-def popcount(x):",
"- x = x - ((x >> 1) & 0x55555555)",
"- x = (x & 0x33333333) + ((x >> 2) & 0x33333333)",
"- x = (x + (x >> 4)) & 0x0F0F0F0F",
"- x = x + (x >> 8)",
"- x = x + (x >> 16)",
"- return x & 0x0000007F",
"-",
"-",
"-import sys",
"-",
"-input = sys.stdin.readline",
"-N = int(eval(input()))",
"-S = input().rstrip()",
"-test = SegmentTree(19, ide_ele, seg_func)",
"-for i in range(N):",
"- val = ord(S[i]) - 97",
"- test.update(i, 1 << val)",
"-for _ in range(int(eval(input()))):",
"- t, l, r = input().split()",
"- t, l = int(t), int(l)",
"- if t == 1:",
"- val = ord(r) - 97",
"- test.update(l - 1, 1 << val)",
"+#####単位元######",
"+ide_ele = 0",
"+# num:n以上の最小の2のべき乗",
"+n = int(eval(input()))",
"+S = eval(input())",
"+Q = int(eval(input()))",
"+num = 2 ** (n - 1).bit_length()",
"+seg = [ide_ele] * 2 * num",
"+alphabetlist = [",
"+ \"a\",",
"+ \"b\",",
"+ \"c\",",
"+ \"d\",",
"+ \"e\",",
"+ \"f\",",
"+ \"g\",",
"+ \"h\",",
"+ \"i\",",
"+ \"j\",",
"+ \"k\",",
"+ \"l\",",
"+ \"m\",",
"+ \"n\",",
"+ \"o\",",
"+ \"p\",",
"+ \"q\",",
"+ \"r\",",
"+ \"s\",",
"+ \"t\",",
"+ \"u\",",
"+ \"v\",",
"+ \"w\",",
"+ \"x\",",
"+ \"y\",",
"+ \"z\",",
"+]",
"+alphabet = {key: alphabetlist.index(key) for key in alphabetlist}",
"+data = [0 for i in range(0, n)]",
"+for i in range(0, n):",
"+ data[i] = 2 ** (alphabet[S[i]])",
"+init(data)",
"+ans = []",
"+for i in range(0, Q):",
"+ q, a, b = input().split()",
"+ if q == \"1\":",
"+ update(int(a) - 1, 2 ** (alphabet[b]))",
"- r = int(r)",
"- res = test.query(l - 1, r - 1)",
"- print((popcount(res)))",
"+ a = int(a)",
"+ b = int(b)",
"+ ans.append(query(a - 1, b))",
"+for i in range(len(ans)):",
"+ x = ans[i]",
"+ print((bin(x).count(\"1\")))"
] | false | 0.13268 | 0.038379 | 3.457095 |
[
"s601135063",
"s616553529"
] |
u380524497
|
p02703
|
python
|
s232527269
|
s223492002
| 1,048 | 619 | 36,004 | 24,232 |
Accepted
|
Accepted
| 40.94 |
def main():
import heapq
n, m, s = list(map(int, input().split()))
if s >= 2500:
s = 2499
edges = [[] for _ in range(n)]
for _ in range(m):
from_, to, cost, time = list(map(int, input().split()))
edges[from_-1].append((to-1, cost, time))
edges[to-1].append((from_-1, cost, time))
banks = []
for i in range(n):
coin, time = list(map(int, input().split()))
banks.append((coin, time))
INF = float('INF')
DP = [[INF] * 2500 for _ in range(n)]
ans = [INF] * n
def push_todo(node, coin, time):
if coin < 0:
return
if time >= DP[node][coin]:
return
heapq.heappush(todo, (time, node, coin))
def charge(node, current_coin, current_time):
coin, time = banks[node]
new_coin = current_coin + coin
if new_coin >= 2500:
new_coin = 2499
push_todo(node, new_coin, current_time+time)
todo = [(0, 0, s)]
while todo:
current_time, node, current_coin = heapq.heappop(todo)
if current_time >= DP[node][current_coin]:
continue
if current_time < ans[node]:
ans[node] = current_time
DP[node][current_coin] = current_time
charge(node, current_coin, current_time)
for to, cost, time in edges[node]:
push_todo(to, current_coin-cost, current_time+time)
for a in ans[1:]:
print(a)
if __name__ == '__main__':
main()
|
def main():
import heapq
n, m, s = list(map(int, input().split()))
if s >= 2500:
s = 2499
edges = [[] for _ in range(n)]
for _ in range(m):
from_, to, cost, time = list(map(int, input().split()))
edges[from_-1].append((to-1, cost, time))
edges[to-1].append((from_-1, cost, time))
banks = []
for i in range(n):
coin, time = list(map(int, input().split()))
banks.append((coin, time))
INF = float('INF')
DP = [[INF] * 2500 for _ in range(n)]
DP[0][s] = 0
ans = [INF] * n
def push_todo(node, coin, time):
if coin < 0:
return
if time >= DP[node][coin]:
return
heapq.heappush(todo, (time, node, coin))
DP[node][coin] = time
def charge(node, current_coin, current_time):
coin, time = banks[node]
new_coin = current_coin + coin
if new_coin >= 2500:
new_coin = 2499
push_todo(node, new_coin, current_time+time)
todo = [(0, 0, s)] # time, node, coin
while todo:
current_time, node, current_coin = heapq.heappop(todo)
if current_time > DP[node][current_coin]:
continue
if current_time < ans[node]:
ans[node] = current_time
charge(node, current_coin, current_time)
for to, cost, time in edges[node]:
push_todo(to, current_coin-cost, current_time+time)
for a in ans[1:]:
print(a)
if __name__ == '__main__':
main()
| 57 | 58 | 1,581 | 1,554 |
def main():
import heapq
n, m, s = list(map(int, input().split()))
if s >= 2500:
s = 2499
edges = [[] for _ in range(n)]
for _ in range(m):
from_, to, cost, time = list(map(int, input().split()))
edges[from_ - 1].append((to - 1, cost, time))
edges[to - 1].append((from_ - 1, cost, time))
banks = []
for i in range(n):
coin, time = list(map(int, input().split()))
banks.append((coin, time))
INF = float("INF")
DP = [[INF] * 2500 for _ in range(n)]
ans = [INF] * n
def push_todo(node, coin, time):
if coin < 0:
return
if time >= DP[node][coin]:
return
heapq.heappush(todo, (time, node, coin))
def charge(node, current_coin, current_time):
coin, time = banks[node]
new_coin = current_coin + coin
if new_coin >= 2500:
new_coin = 2499
push_todo(node, new_coin, current_time + time)
todo = [(0, 0, s)]
while todo:
current_time, node, current_coin = heapq.heappop(todo)
if current_time >= DP[node][current_coin]:
continue
if current_time < ans[node]:
ans[node] = current_time
DP[node][current_coin] = current_time
charge(node, current_coin, current_time)
for to, cost, time in edges[node]:
push_todo(to, current_coin - cost, current_time + time)
for a in ans[1:]:
print(a)
if __name__ == "__main__":
main()
|
def main():
import heapq
n, m, s = list(map(int, input().split()))
if s >= 2500:
s = 2499
edges = [[] for _ in range(n)]
for _ in range(m):
from_, to, cost, time = list(map(int, input().split()))
edges[from_ - 1].append((to - 1, cost, time))
edges[to - 1].append((from_ - 1, cost, time))
banks = []
for i in range(n):
coin, time = list(map(int, input().split()))
banks.append((coin, time))
INF = float("INF")
DP = [[INF] * 2500 for _ in range(n)]
DP[0][s] = 0
ans = [INF] * n
def push_todo(node, coin, time):
if coin < 0:
return
if time >= DP[node][coin]:
return
heapq.heappush(todo, (time, node, coin))
DP[node][coin] = time
def charge(node, current_coin, current_time):
coin, time = banks[node]
new_coin = current_coin + coin
if new_coin >= 2500:
new_coin = 2499
push_todo(node, new_coin, current_time + time)
todo = [(0, 0, s)] # time, node, coin
while todo:
current_time, node, current_coin = heapq.heappop(todo)
if current_time > DP[node][current_coin]:
continue
if current_time < ans[node]:
ans[node] = current_time
charge(node, current_coin, current_time)
for to, cost, time in edges[node]:
push_todo(to, current_coin - cost, current_time + time)
for a in ans[1:]:
print(a)
if __name__ == "__main__":
main()
| false | 1.724138 |
[
"+ DP[0][s] = 0",
"+ DP[node][coin] = time",
"- todo = [(0, 0, s)]",
"+ todo = [(0, 0, s)] # time, node, coin",
"- if current_time >= DP[node][current_coin]:",
"+ if current_time > DP[node][current_coin]:",
"- DP[node][current_coin] = current_time"
] | false | 0.067242 | 0.059817 | 1.124121 |
[
"s232527269",
"s223492002"
] |
u575431498
|
p02803
|
python
|
s348966207
|
s294851473
| 1,528 | 542 | 3,944 | 3,436 |
Accepted
|
Accepted
| 64.53 |
import queue
H, W = list(map(int, input().split()))
S = [list(eval(input())) for _ in range(H)]
dxs = [0, 0, 1, -1]
dys = [1, -1, 0, 0]
cand = []
for j in range(H):
for i in range(W):
if S[j][i] == '#':
continue
q = queue.Queue()
q.put((i, j, 0))
field = [[-1] * W for _ in range(H)]
field[j][i] = 0
while not q.empty():
p = q.get()
for dx, dy in zip(dxs, dys):
x, y = p[0] + dx, p[1] + dy
if not (0 <= x < W) or not (0 <= y < H) or S[y][x] == '#' or field[y][x] != -1:
continue
field[y][x] = p[2] + 1
q.put((x, y, p[2] + 1))
cand.append(max(max(row) for row in field))
print((max(cand)))
|
from collections import deque
H, W = list(map(int, input().split()))
S = [list(eval(input())) for _ in range(H)]
dxs = [0, 0, 1, -1]
dys = [1, -1, 0, 0]
cand = []
for j in range(H):
for i in range(W):
if S[j][i] == '#':
continue
q = deque()
q.append((i, j, 0))
field = [[-1] * W for _ in range(H)]
field[j][i] = 0
while q:
p = q.popleft()
for dx, dy in zip(dxs, dys):
x, y = p[0] + dx, p[1] + dy
if not (0 <= x < W) or not (0 <= y < H) or S[y][x] == '#' or field[y][x] != -1:
continue
field[y][x] = p[2] + 1
q.append((x, y, p[2] + 1))
cand.append(max(max(row) for row in field))
print((max(cand)))
| 25 | 25 | 779 | 788 |
import queue
H, W = list(map(int, input().split()))
S = [list(eval(input())) for _ in range(H)]
dxs = [0, 0, 1, -1]
dys = [1, -1, 0, 0]
cand = []
for j in range(H):
for i in range(W):
if S[j][i] == "#":
continue
q = queue.Queue()
q.put((i, j, 0))
field = [[-1] * W for _ in range(H)]
field[j][i] = 0
while not q.empty():
p = q.get()
for dx, dy in zip(dxs, dys):
x, y = p[0] + dx, p[1] + dy
if (
not (0 <= x < W)
or not (0 <= y < H)
or S[y][x] == "#"
or field[y][x] != -1
):
continue
field[y][x] = p[2] + 1
q.put((x, y, p[2] + 1))
cand.append(max(max(row) for row in field))
print((max(cand)))
|
from collections import deque
H, W = list(map(int, input().split()))
S = [list(eval(input())) for _ in range(H)]
dxs = [0, 0, 1, -1]
dys = [1, -1, 0, 0]
cand = []
for j in range(H):
for i in range(W):
if S[j][i] == "#":
continue
q = deque()
q.append((i, j, 0))
field = [[-1] * W for _ in range(H)]
field[j][i] = 0
while q:
p = q.popleft()
for dx, dy in zip(dxs, dys):
x, y = p[0] + dx, p[1] + dy
if (
not (0 <= x < W)
or not (0 <= y < H)
or S[y][x] == "#"
or field[y][x] != -1
):
continue
field[y][x] = p[2] + 1
q.append((x, y, p[2] + 1))
cand.append(max(max(row) for row in field))
print((max(cand)))
| false | 0 |
[
"-import queue",
"+from collections import deque",
"- q = queue.Queue()",
"- q.put((i, j, 0))",
"+ q = deque()",
"+ q.append((i, j, 0))",
"- while not q.empty():",
"- p = q.get()",
"+ while q:",
"+ p = q.popleft()",
"- q.put((x, y, p[2] + 1))",
"+ q.append((x, y, p[2] + 1))"
] | false | 0.073043 | 0.057267 | 1.275465 |
[
"s348966207",
"s294851473"
] |
u909375661
|
p02767
|
python
|
s354848180
|
s832710198
| 21 | 19 | 3,064 | 3,060 |
Accepted
|
Accepted
| 9.52 |
N = int(eval(input()))
X = list(map(int, input().split()))
m = min(X)
M = max(X)
cost = [1000000009 for _ in range(101)]
for p in range(1,101):
c = 0
for x in X:
c += (x-p)**2
cost[p] = c
print((min(cost)))
|
N = int(eval(input()))
X = list(map(int, input().split()))
m = min(X)
M = max(X)
min_val = 100 * 100 * 100
for p in range(m, M+1):
score = 0
for x in X:
score += (x-p)*(x-p)
if score < min_val: min_val = score
print(min_val)
| 14 | 13 | 234 | 254 |
N = int(eval(input()))
X = list(map(int, input().split()))
m = min(X)
M = max(X)
cost = [1000000009 for _ in range(101)]
for p in range(1, 101):
c = 0
for x in X:
c += (x - p) ** 2
cost[p] = c
print((min(cost)))
|
N = int(eval(input()))
X = list(map(int, input().split()))
m = min(X)
M = max(X)
min_val = 100 * 100 * 100
for p in range(m, M + 1):
score = 0
for x in X:
score += (x - p) * (x - p)
if score < min_val:
min_val = score
print(min_val)
| false | 7.142857 |
[
"-cost = [1000000009 for _ in range(101)]",
"-for p in range(1, 101):",
"- c = 0",
"+min_val = 100 * 100 * 100",
"+for p in range(m, M + 1):",
"+ score = 0",
"- c += (x - p) ** 2",
"- cost[p] = c",
"-print((min(cost)))",
"+ score += (x - p) * (x - p)",
"+ if score < min_val:",
"+ min_val = score",
"+print(min_val)"
] | false | 0.036295 | 0.035678 | 1.01729 |
[
"s354848180",
"s832710198"
] |
u127499732
|
p03700
|
python
|
s676863408
|
s323329748
| 1,630 | 738 | 20,156 | 20,132 |
Accepted
|
Accepted
| 54.72 |
def main():
from math import ceil
from copy import deepcopy
n, a, b, *k = list(map(int, open(0).read().split()))
k.sort()
def check(x):
q = deepcopy(k)
cnt = 0
while q:
p = q.pop() - x * b
if p <= 0:
break
cnt += ceil(p / (a - b))
return cnt <= x
l = 0
r = k[-1]
m = (l + r) // 2
while l + 1 < r:
if check(m):
r = m
else:
l = m
m = (l + r) // 2
print((m+1))
if __name__ == '__main__':
main()
|
def main():
from math import ceil
n, a, b, *k = list(map(int, open(0).read().split()))
k.sort()
l = 0
r = k[-1]
m = (l + r) // 2
while l + 1 < r:
c = sum(ceil((i - m * b) / (a - b)) if i - m * b > 0 else 0 for i in k)
if c <= m:
r = m
else:
l = m
m = (l + r) // 2
print(r)
if __name__ == '__main__':
main()
| 32 | 21 | 597 | 417 |
def main():
from math import ceil
from copy import deepcopy
n, a, b, *k = list(map(int, open(0).read().split()))
k.sort()
def check(x):
q = deepcopy(k)
cnt = 0
while q:
p = q.pop() - x * b
if p <= 0:
break
cnt += ceil(p / (a - b))
return cnt <= x
l = 0
r = k[-1]
m = (l + r) // 2
while l + 1 < r:
if check(m):
r = m
else:
l = m
m = (l + r) // 2
print((m + 1))
if __name__ == "__main__":
main()
|
def main():
from math import ceil
n, a, b, *k = list(map(int, open(0).read().split()))
k.sort()
l = 0
r = k[-1]
m = (l + r) // 2
while l + 1 < r:
c = sum(ceil((i - m * b) / (a - b)) if i - m * b > 0 else 0 for i in k)
if c <= m:
r = m
else:
l = m
m = (l + r) // 2
print(r)
if __name__ == "__main__":
main()
| false | 34.375 |
[
"- from copy import deepcopy",
"-",
"- def check(x):",
"- q = deepcopy(k)",
"- cnt = 0",
"- while q:",
"- p = q.pop() - x * b",
"- if p <= 0:",
"- break",
"- cnt += ceil(p / (a - b))",
"- return cnt <= x",
"-",
"- if check(m):",
"+ c = sum(ceil((i - m * b) / (a - b)) if i - m * b > 0 else 0 for i in k)",
"+ if c <= m:",
"- print((m + 1))",
"+ print(r)"
] | false | 0.075311 | 0.087838 | 0.857387 |
[
"s676863408",
"s323329748"
] |
u515740713
|
p02549
|
python
|
s550418395
|
s678454634
| 1,488 | 108 | 24,572 | 76,868 |
Accepted
|
Accepted
| 92.74 |
# -*- coding: utf-8 -*-
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
MOD = 998244353
N, K = list(map(int, readline().split()))
data = []
for _ in range(K):
L,R = list(map(int, readline().split()))
data.append((L,R))
data = sorted(data)
A = [0]*(N+1)
A[1] = 1
S = [0]*(N+1)
S[1] = 1
for i in range(2,N+1):
for k in range(K):
L,R = data[k]
A[i] += (S[max(0,i-L)]- S[max(0,i-R-1)]) % MOD
A[i] %= MOD
S[i] = (S[i-1] + A[i]) % MOD
print((A[N]))
|
# -*- coding: utf-8 -*-
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
MOD = 998244353
N, K = list(map(int, readline().split()))
data = []
for _ in range(K):
L,R = list(map(int, readline().split()))
data.append((L,R))
A = [0]*(N+1)
A[1] = 1
S = [0]*(N+1)
S[1] = 1
for i in range(2,N+1):
for k in range(K):
L,R = data[k]
A[i] += (S[max(0,i-L)]- S[max(0,i-R-1)]) % MOD
A[i] %= MOD
S[i] = (S[i-1] + A[i]) % MOD
print((A[N]))
| 26 | 25 | 569 | 548 |
# -*- coding: utf-8 -*-
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
MOD = 998244353
N, K = list(map(int, readline().split()))
data = []
for _ in range(K):
L, R = list(map(int, readline().split()))
data.append((L, R))
data = sorted(data)
A = [0] * (N + 1)
A[1] = 1
S = [0] * (N + 1)
S[1] = 1
for i in range(2, N + 1):
for k in range(K):
L, R = data[k]
A[i] += (S[max(0, i - L)] - S[max(0, i - R - 1)]) % MOD
A[i] %= MOD
S[i] = (S[i - 1] + A[i]) % MOD
print((A[N]))
|
# -*- coding: utf-8 -*-
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
MOD = 998244353
N, K = list(map(int, readline().split()))
data = []
for _ in range(K):
L, R = list(map(int, readline().split()))
data.append((L, R))
A = [0] * (N + 1)
A[1] = 1
S = [0] * (N + 1)
S[1] = 1
for i in range(2, N + 1):
for k in range(K):
L, R = data[k]
A[i] += (S[max(0, i - L)] - S[max(0, i - R - 1)]) % MOD
A[i] %= MOD
S[i] = (S[i - 1] + A[i]) % MOD
print((A[N]))
| false | 3.846154 |
[
"-data = sorted(data)"
] | false | 0.053181 | 0.035831 | 1.484214 |
[
"s550418395",
"s678454634"
] |
u969850098
|
p03713
|
python
|
s733739753
|
s218787061
| 422 | 52 | 11,060 | 5,576 |
Accepted
|
Accepted
| 87.68 |
import sys
readline = sys.stdin.readline
from math import floor, ceil
def main():
H, W = list(map(int, readline().rstrip().split()))
ans = H * W
if H >= 3:
ans = min(ans, abs(W*(H//3) - W*(H-H//3*2)))
if W >= 3:
ans = min(ans, abs(H*(W//3) - H*(W-W//3*2)))
# 縦にスライス + 残りに横にスライス
# x1_cand = [floor(W/3), ceil(W/3)]
x1_cand = [i for i in range(1, W)]
y1 = H
for x1 in x1_cand:
x2 = W - x1
x3 = x2
y2 = H // 2
y3 = H - y2
ans = min(ans, max((x1*y1), (x2*y2), (x3*y3)) - min((x1*y1), (x2*y2), (x3*y3)))
x2 = (W-x1) // 2
x3 = (W-x1-x2)
ans = min(ans, max((x1*H), (x2*H), (x3*H)) - min((x1*H), (x2*H), (x3*H)))
# 横にスライス + 残りに縦にスライス
# y1_cand = [floor(H/3), ceil(H/3)]
y1_cand = [i for i in range(1, H)]
x1 = W
for y1 in y1_cand:
y2 = H - y1
y3 = y2
x2 = W // 2
x3 = W - x2
ans = min(ans, max((x1*y1), (x2*y2), (x3*y3)) - min((x1*y1), (x2*y2), (x3*y3)))
y2 = (H-y1) // 2
y3 = (H-y1-y2)
ans = min(ans, max((W*y1), (W*y2), (W*y3)) - min((W*y1), (W*y2), (W*y3)))
print(ans)
if __name__ == '__main__':
main()
|
import sys
readline = sys.stdin.readline
from math import floor, ceil
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN
def round(f, r=0):
return Decimal(str(f)).quantize(Decimal(str(r)), rounding=ROUND_HALF_UP)
def main():
H, W = list(map(int, readline().rstrip().split()))
ans = H * W
if H >= 3:
y1 = int(round(H/3))
y2 = (H-y1) // 2
y3 = H - y1 - y2
ans = min(ans, max(W*y1, W*y2, W*y3)-min(W*y1, W*y2, W*y3))
if W >= 3:
x1 = int(round(W/3))
x2 = (W-x1) // 2
x3 = W - x1 - x2
ans = min(ans, max(x1*H, x2*H, x3*H)-min(x1*H, x2*H, x3*H))
# 縦にスライス + 残りに横にスライス
x1_cand = [floor(W/3), ceil(W/3)]
# x1_cand = [i for i in range(1, W)]
y1 = H
for x1 in x1_cand:
x2 = W - x1
x3 = x2
y2 = H // 2
y3 = H - y2
ans = min(ans, max((x1*y1), (x2*y2), (x3*y3)) - min((x1*y1), (x2*y2), (x3*y3)))
# 横にスライス + 残りに縦にスライス
y1_cand = [floor(H/3), ceil(H/3)]
# y1_cand = [i for i in range(1, H)]
x1 = W
for y1 in y1_cand:
y2 = H - y1
y3 = y2
x2 = W // 2
x3 = W - x2
ans = min(ans, max((x1*y1), (x2*y2), (x3*y3)) - min((x1*y1), (x2*y2), (x3*y3)))
print(ans)
if __name__ == '__main__':
main()
| 46 | 47 | 1,255 | 1,338 |
import sys
readline = sys.stdin.readline
from math import floor, ceil
def main():
H, W = list(map(int, readline().rstrip().split()))
ans = H * W
if H >= 3:
ans = min(ans, abs(W * (H // 3) - W * (H - H // 3 * 2)))
if W >= 3:
ans = min(ans, abs(H * (W // 3) - H * (W - W // 3 * 2)))
# 縦にスライス + 残りに横にスライス
# x1_cand = [floor(W/3), ceil(W/3)]
x1_cand = [i for i in range(1, W)]
y1 = H
for x1 in x1_cand:
x2 = W - x1
x3 = x2
y2 = H // 2
y3 = H - y2
ans = min(
ans,
max((x1 * y1), (x2 * y2), (x3 * y3)) - min((x1 * y1), (x2 * y2), (x3 * y3)),
)
x2 = (W - x1) // 2
x3 = W - x1 - x2
ans = min(
ans, max((x1 * H), (x2 * H), (x3 * H)) - min((x1 * H), (x2 * H), (x3 * H))
)
# 横にスライス + 残りに縦にスライス
# y1_cand = [floor(H/3), ceil(H/3)]
y1_cand = [i for i in range(1, H)]
x1 = W
for y1 in y1_cand:
y2 = H - y1
y3 = y2
x2 = W // 2
x3 = W - x2
ans = min(
ans,
max((x1 * y1), (x2 * y2), (x3 * y3)) - min((x1 * y1), (x2 * y2), (x3 * y3)),
)
y2 = (H - y1) // 2
y3 = H - y1 - y2
ans = min(
ans, max((W * y1), (W * y2), (W * y3)) - min((W * y1), (W * y2), (W * y3))
)
print(ans)
if __name__ == "__main__":
main()
|
import sys
readline = sys.stdin.readline
from math import floor, ceil
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN
def round(f, r=0):
return Decimal(str(f)).quantize(Decimal(str(r)), rounding=ROUND_HALF_UP)
def main():
H, W = list(map(int, readline().rstrip().split()))
ans = H * W
if H >= 3:
y1 = int(round(H / 3))
y2 = (H - y1) // 2
y3 = H - y1 - y2
ans = min(ans, max(W * y1, W * y2, W * y3) - min(W * y1, W * y2, W * y3))
if W >= 3:
x1 = int(round(W / 3))
x2 = (W - x1) // 2
x3 = W - x1 - x2
ans = min(ans, max(x1 * H, x2 * H, x3 * H) - min(x1 * H, x2 * H, x3 * H))
# 縦にスライス + 残りに横にスライス
x1_cand = [floor(W / 3), ceil(W / 3)]
# x1_cand = [i for i in range(1, W)]
y1 = H
for x1 in x1_cand:
x2 = W - x1
x3 = x2
y2 = H // 2
y3 = H - y2
ans = min(
ans,
max((x1 * y1), (x2 * y2), (x3 * y3)) - min((x1 * y1), (x2 * y2), (x3 * y3)),
)
# 横にスライス + 残りに縦にスライス
y1_cand = [floor(H / 3), ceil(H / 3)]
# y1_cand = [i for i in range(1, H)]
x1 = W
for y1 in y1_cand:
y2 = H - y1
y3 = y2
x2 = W // 2
x3 = W - x2
ans = min(
ans,
max((x1 * y1), (x2 * y2), (x3 * y3)) - min((x1 * y1), (x2 * y2), (x3 * y3)),
)
print(ans)
if __name__ == "__main__":
main()
| false | 2.12766 |
[
"+from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN",
"+",
"+",
"+def round(f, r=0):",
"+ return Decimal(str(f)).quantize(Decimal(str(r)), rounding=ROUND_HALF_UP)",
"- ans = min(ans, abs(W * (H // 3) - W * (H - H // 3 * 2)))",
"+ y1 = int(round(H / 3))",
"+ y2 = (H - y1) // 2",
"+ y3 = H - y1 - y2",
"+ ans = min(ans, max(W * y1, W * y2, W * y3) - min(W * y1, W * y2, W * y3))",
"- ans = min(ans, abs(H * (W // 3) - H * (W - W // 3 * 2)))",
"+ x1 = int(round(W / 3))",
"+ x2 = (W - x1) // 2",
"+ x3 = W - x1 - x2",
"+ ans = min(ans, max(x1 * H, x2 * H, x3 * H) - min(x1 * H, x2 * H, x3 * H))",
"- # x1_cand = [floor(W/3), ceil(W/3)]",
"- x1_cand = [i for i in range(1, W)]",
"+ x1_cand = [floor(W / 3), ceil(W / 3)]",
"+ # x1_cand = [i for i in range(1, W)]",
"- x2 = (W - x1) // 2",
"- x3 = W - x1 - x2",
"- ans = min(",
"- ans, max((x1 * H), (x2 * H), (x3 * H)) - min((x1 * H), (x2 * H), (x3 * H))",
"- )",
"- # y1_cand = [floor(H/3), ceil(H/3)]",
"- y1_cand = [i for i in range(1, H)]",
"+ y1_cand = [floor(H / 3), ceil(H / 3)]",
"+ # y1_cand = [i for i in range(1, H)]",
"- y2 = (H - y1) // 2",
"- y3 = H - y1 - y2",
"- ans = min(",
"- ans, max((W * y1), (W * y2), (W * y3)) - min((W * y1), (W * y2), (W * y3))",
"- )"
] | false | 0.365408 | 0.007435 | 49.145497 |
[
"s733739753",
"s218787061"
] |
u360116509
|
p02862
|
python
|
s427906054
|
s127757705
| 900 | 252 | 82,164 | 39,796 |
Accepted
|
Accepted
| 72 |
import math
P = 10**9 + 7
X, Y = list(map(int, input().split()))
if (X + Y) % 3 > 0:
print((0))
exit()
n = (X + Y) // 3
x = X - n
y = Y - n
if 0 > x or 0 > y:
print((0))
exit()
fact = [0] * (x + y + 1)
inv = [0] * (x + y + 1)
fact_inv = [0] * (x + y + 1)
fact[0], fact[1] = 1, 1
inv[0], inv[1] = 0, 1
fact_inv[0], fact_inv[1] = 1, 1
for i in range(2, x + y + 1):
fact[i] = (fact[i - 1] * i) % P
inv[i] = (-inv[P % i] * (P // i)) % P
fact_inv[i] = (fact_inv[i - 1] * inv[i]) % P
print(((fact[x + y] * fact_inv[x] * fact_inv[y]) % P))
|
P = 10**9 + 7
X, Y = list(map(int, input().split()))
if (X + Y) % 3 > 0:
print((0))
exit()
n = (X + Y) // 3
x = X - n
y = Y - n
if 0 > x or 0 > y:
print((0))
exit()
fact = [0] * (x + y + 1)
inv = [0] * (x + y + 1)
fact_inv = [0] * (x + y + 1)
fact[0], fact[1] = 1, 1
inv[0], inv[1] = 0, 1
fact_inv[0], fact_inv[1] = 1, 1
for i in range(2, x + y + 1):
fact[i] = (fact[i - 1] * i) % P
print(((fact[x + y] * pow(fact[x], P - 2, P) * pow(fact[y], P - 2, P)) % P))
| 24 | 20 | 573 | 487 |
import math
P = 10**9 + 7
X, Y = list(map(int, input().split()))
if (X + Y) % 3 > 0:
print((0))
exit()
n = (X + Y) // 3
x = X - n
y = Y - n
if 0 > x or 0 > y:
print((0))
exit()
fact = [0] * (x + y + 1)
inv = [0] * (x + y + 1)
fact_inv = [0] * (x + y + 1)
fact[0], fact[1] = 1, 1
inv[0], inv[1] = 0, 1
fact_inv[0], fact_inv[1] = 1, 1
for i in range(2, x + y + 1):
fact[i] = (fact[i - 1] * i) % P
inv[i] = (-inv[P % i] * (P // i)) % P
fact_inv[i] = (fact_inv[i - 1] * inv[i]) % P
print(((fact[x + y] * fact_inv[x] * fact_inv[y]) % P))
|
P = 10**9 + 7
X, Y = list(map(int, input().split()))
if (X + Y) % 3 > 0:
print((0))
exit()
n = (X + Y) // 3
x = X - n
y = Y - n
if 0 > x or 0 > y:
print((0))
exit()
fact = [0] * (x + y + 1)
inv = [0] * (x + y + 1)
fact_inv = [0] * (x + y + 1)
fact[0], fact[1] = 1, 1
inv[0], inv[1] = 0, 1
fact_inv[0], fact_inv[1] = 1, 1
for i in range(2, x + y + 1):
fact[i] = (fact[i - 1] * i) % P
print(((fact[x + y] * pow(fact[x], P - 2, P) * pow(fact[y], P - 2, P)) % P))
| false | 16.666667 |
[
"-import math",
"-",
"- inv[i] = (-inv[P % i] * (P // i)) % P",
"- fact_inv[i] = (fact_inv[i - 1] * inv[i]) % P",
"-print(((fact[x + y] * fact_inv[x] * fact_inv[y]) % P))",
"+print(((fact[x + y] * pow(fact[x], P - 2, P) * pow(fact[y], P - 2, P)) % P))"
] | false | 0.580846 | 0.148862 | 3.901901 |
[
"s427906054",
"s127757705"
] |
u309120194
|
p02724
|
python
|
s896690878
|
s137519980
| 27 | 24 | 9,148 | 9,164 |
Accepted
|
Accepted
| 11.11 |
X = int(eval(input()))
a = X // 500
X = X % 500
b = X // 5
print((a*1000+b*5))
|
X = int(eval(input()))
a = X // 500 # 500円硬貨の枚数
X = X % 500 # 端数
b = X // 5 # 5円硬貨の枚数
print((a*1000+b*5))
| 7 | 7 | 78 | 107 |
X = int(eval(input()))
a = X // 500
X = X % 500
b = X // 5
print((a * 1000 + b * 5))
|
X = int(eval(input()))
a = X // 500 # 500円硬貨の枚数
X = X % 500 # 端数
b = X // 5 # 5円硬貨の枚数
print((a * 1000 + b * 5))
| false | 0 |
[
"-a = X // 500",
"-X = X % 500",
"-b = X // 5",
"+a = X // 500 # 500円硬貨の枚数",
"+X = X % 500 # 端数",
"+b = X // 5 # 5円硬貨の枚数"
] | false | 0.116581 | 0.054519 | 2.138364 |
[
"s896690878",
"s137519980"
] |
u159994501
|
p03400
|
python
|
s570969950
|
s354486558
| 20 | 17 | 3,060 | 2,940 |
Accepted
|
Accepted
| 15 |
N = int(eval(input()))
D, X = list(map(int, input().split()))
A = [int(eval(input())) for i in range(N)]
t = 0
c = X
for i in range(N):
t = A[i]
for j in range(100):
if 1 + t * j <= D:
c += 1
else:
break
print(c)
|
N = int(eval(input()))
D, X = list(map(int, input().split()))
D -= 1
for i in range(N):
A = int(eval(input()))
X += D // A
print((X + N))
| 13 | 7 | 255 | 132 |
N = int(eval(input()))
D, X = list(map(int, input().split()))
A = [int(eval(input())) for i in range(N)]
t = 0
c = X
for i in range(N):
t = A[i]
for j in range(100):
if 1 + t * j <= D:
c += 1
else:
break
print(c)
|
N = int(eval(input()))
D, X = list(map(int, input().split()))
D -= 1
for i in range(N):
A = int(eval(input()))
X += D // A
print((X + N))
| false | 46.153846 |
[
"-A = [int(eval(input())) for i in range(N)]",
"-t = 0",
"-c = X",
"+D -= 1",
"- t = A[i]",
"- for j in range(100):",
"- if 1 + t * j <= D:",
"- c += 1",
"- else:",
"- break",
"-print(c)",
"+ A = int(eval(input()))",
"+ X += D // A",
"+print((X + N))"
] | false | 0.047145 | 0.047001 | 1.00306 |
[
"s570969950",
"s354486558"
] |
u072053884
|
p02370
|
python
|
s825719408
|
s855023918
| 130 | 110 | 11,408 | 11,504 |
Accepted
|
Accepted
| 15.38 |
import sys
f_i = sys.stdin
V, E = map(int, f_i.readline().split())
adj_list = [[] for i in range(V)]
is_visited = [False] * V
indeg = [0] * V
for l_i in f_i:
s, t = map(int, l_i.split())
adj_list[s].append(t)
indeg[t] += 1
import collections
Q = collections.deque()
out = collections.deque()
def bfs(s):
Q.append(s)
is_visited[s] = True
while Q:
u = Q.popleft()
out.append(u)
for v in adj_list[u]:
indeg[v] -= 1
if indeg[v] == 0 and is_visited[v] == False:
is_visited[v] = True
Q.append(v)
# Topological Sort
for u in range(V):
if indeg[u] == 0 and is_visited[u] == False:
bfs(u)
print(*out, sep = '\n')
|
import sys
f_i = sys.stdin
V, E = map(int, f_i.readline().split())
adj_list = [[] for i in range(V)]
is_visited = [False] * V
for l_i in f_i:
s, t = map(int, l_i.split())
adj_list[s].append(t)
import collections
out = collections.deque()
def dfs(u):
is_visited[u] = True
for v in adj_list[u]:
if not is_visited[v]:
dfs(v)
out.appendleft(u)
for s in range(V):
if not is_visited[s]:
dfs(s)
print(*out, sep = '\n')
| 44 | 30 | 777 | 502 |
import sys
f_i = sys.stdin
V, E = map(int, f_i.readline().split())
adj_list = [[] for i in range(V)]
is_visited = [False] * V
indeg = [0] * V
for l_i in f_i:
s, t = map(int, l_i.split())
adj_list[s].append(t)
indeg[t] += 1
import collections
Q = collections.deque()
out = collections.deque()
def bfs(s):
Q.append(s)
is_visited[s] = True
while Q:
u = Q.popleft()
out.append(u)
for v in adj_list[u]:
indeg[v] -= 1
if indeg[v] == 0 and is_visited[v] == False:
is_visited[v] = True
Q.append(v)
# Topological Sort
for u in range(V):
if indeg[u] == 0 and is_visited[u] == False:
bfs(u)
print(*out, sep="\n")
|
import sys
f_i = sys.stdin
V, E = map(int, f_i.readline().split())
adj_list = [[] for i in range(V)]
is_visited = [False] * V
for l_i in f_i:
s, t = map(int, l_i.split())
adj_list[s].append(t)
import collections
out = collections.deque()
def dfs(u):
is_visited[u] = True
for v in adj_list[u]:
if not is_visited[v]:
dfs(v)
out.appendleft(u)
for s in range(V):
if not is_visited[s]:
dfs(s)
print(*out, sep="\n")
| false | 31.818182 |
[
"-indeg = [0] * V",
"- indeg[t] += 1",
"-Q = collections.deque()",
"-def bfs(s):",
"- Q.append(s)",
"- is_visited[s] = True",
"- while Q:",
"- u = Q.popleft()",
"- out.append(u)",
"- for v in adj_list[u]:",
"- indeg[v] -= 1",
"- if indeg[v] == 0 and is_visited[v] == False:",
"- is_visited[v] = True",
"- Q.append(v)",
"+def dfs(u):",
"+ is_visited[u] = True",
"+ for v in adj_list[u]:",
"+ if not is_visited[v]:",
"+ dfs(v)",
"+ out.appendleft(u)",
"-# Topological Sort",
"-for u in range(V):",
"- if indeg[u] == 0 and is_visited[u] == False:",
"- bfs(u)",
"+for s in range(V):",
"+ if not is_visited[s]:",
"+ dfs(s)"
] | false | 0.048355 | 0.007254 | 6.666341 |
[
"s825719408",
"s855023918"
] |
u223904637
|
p02579
|
python
|
s809104787
|
s801576567
| 882 | 674 | 190,784 | 147,132 |
Accepted
|
Accepted
| 23.58 |
from collections import deque
def main():
h,w=list(map(int,input().split()))
sx,sy=list(map(int,input().split()))
sx-=1
sy-=1
gx,gy=list(map(int,input().split()))
gx-=1
gy-=1
g=[tuple(eval(input())) for _ in range(h)]
v=[[0 for j in range(w)] for i in range(h)]
q=deque([[sx,sy]])
v[sx][sy]=1
ans=0
k=[[0,1],[0,-1],[1,0],[-1,0]]
while True:
l=[]
while q:
x,y=q.popleft()
l.append([x,y])
if x==gx and y==gy:
print(ans)
exit()
for a,b in k:
nx=x+a
ny=y+b
if 0<=nx<h and 0<=ny<w and g[nx][ny]=='.' and v[nx][ny]==0:
q.append([nx,ny])
v[nx][ny]=1
if len(l)==0:
break
for x,y in l:
for a in range(-2,3):
for b in range(-2,3):
if a*b==0 and abs(a+b)<=1:
continue
nx=x+a
ny=y+b
if 0<=nx<h and 0<=ny<w and g[nx][ny]=='.' and v[nx][ny]==0:
q.append([nx,ny])
v[nx][ny]=1
ans+=1
print((-1))
if __name__=='__main__':
main()
|
from heapq import heappush,heappop
from collections import deque
h,w=list(map(int,input().split()))
sx,sy=list(map(int,input().split()))
sx-=1
sy-=1
gx,gy=list(map(int,input().split()))
gx-=1
gy-=1
g=[list(eval(input())) for _ in range(h)]
v=[[0 for j in range(w)] for i in range(h)]
v2=[[0 for j in range(w)] for i in range(h)]
q=deque([])
q.append([0,sx,sy])
while q:
c,x,y=q.popleft()
if x==gx and y==gy:
print(c)
exit()
if v[x][y]==1:
continue
v[x][y]=1
for a in range(-2,3):
for b in range(-2,3):
if a==b==0:
continue
if a*b==0 and abs(a+b)==1:
nx=x+a
ny=y+b
if 0<=nx<h and 0<=ny<w and g[nx][ny]=='.' and v[nx][ny]==0:
q.appendleft([c,nx,ny])
continue
nx=x+a
ny=y+b
if 0<=nx<h and 0<=ny<w and g[nx][ny]=='.' and v[nx][ny]==0 and v2[nx][ny]==0:
q.append([c+1,nx,ny])
v2[nx][ny]=1
print((-1))
| 45 | 38 | 1,308 | 1,051 |
from collections import deque
def main():
h, w = list(map(int, input().split()))
sx, sy = list(map(int, input().split()))
sx -= 1
sy -= 1
gx, gy = list(map(int, input().split()))
gx -= 1
gy -= 1
g = [tuple(eval(input())) for _ in range(h)]
v = [[0 for j in range(w)] for i in range(h)]
q = deque([[sx, sy]])
v[sx][sy] = 1
ans = 0
k = [[0, 1], [0, -1], [1, 0], [-1, 0]]
while True:
l = []
while q:
x, y = q.popleft()
l.append([x, y])
if x == gx and y == gy:
print(ans)
exit()
for a, b in k:
nx = x + a
ny = y + b
if 0 <= nx < h and 0 <= ny < w and g[nx][ny] == "." and v[nx][ny] == 0:
q.append([nx, ny])
v[nx][ny] = 1
if len(l) == 0:
break
for x, y in l:
for a in range(-2, 3):
for b in range(-2, 3):
if a * b == 0 and abs(a + b) <= 1:
continue
nx = x + a
ny = y + b
if (
0 <= nx < h
and 0 <= ny < w
and g[nx][ny] == "."
and v[nx][ny] == 0
):
q.append([nx, ny])
v[nx][ny] = 1
ans += 1
print((-1))
if __name__ == "__main__":
main()
|
from heapq import heappush, heappop
from collections import deque
h, w = list(map(int, input().split()))
sx, sy = list(map(int, input().split()))
sx -= 1
sy -= 1
gx, gy = list(map(int, input().split()))
gx -= 1
gy -= 1
g = [list(eval(input())) for _ in range(h)]
v = [[0 for j in range(w)] for i in range(h)]
v2 = [[0 for j in range(w)] for i in range(h)]
q = deque([])
q.append([0, sx, sy])
while q:
c, x, y = q.popleft()
if x == gx and y == gy:
print(c)
exit()
if v[x][y] == 1:
continue
v[x][y] = 1
for a in range(-2, 3):
for b in range(-2, 3):
if a == b == 0:
continue
if a * b == 0 and abs(a + b) == 1:
nx = x + a
ny = y + b
if 0 <= nx < h and 0 <= ny < w and g[nx][ny] == "." and v[nx][ny] == 0:
q.appendleft([c, nx, ny])
continue
nx = x + a
ny = y + b
if (
0 <= nx < h
and 0 <= ny < w
and g[nx][ny] == "."
and v[nx][ny] == 0
and v2[nx][ny] == 0
):
q.append([c + 1, nx, ny])
v2[nx][ny] = 1
print((-1))
| false | 15.555556 |
[
"+from heapq import heappush, heappop",
"-",
"-def main():",
"- h, w = list(map(int, input().split()))",
"- sx, sy = list(map(int, input().split()))",
"- sx -= 1",
"- sy -= 1",
"- gx, gy = list(map(int, input().split()))",
"- gx -= 1",
"- gy -= 1",
"- g = [tuple(eval(input())) for _ in range(h)]",
"- v = [[0 for j in range(w)] for i in range(h)]",
"- q = deque([[sx, sy]])",
"- v[sx][sy] = 1",
"- ans = 0",
"- k = [[0, 1], [0, -1], [1, 0], [-1, 0]]",
"- while True:",
"- l = []",
"- while q:",
"- x, y = q.popleft()",
"- l.append([x, y])",
"- if x == gx and y == gy:",
"- print(ans)",
"- exit()",
"- for a, b in k:",
"+h, w = list(map(int, input().split()))",
"+sx, sy = list(map(int, input().split()))",
"+sx -= 1",
"+sy -= 1",
"+gx, gy = list(map(int, input().split()))",
"+gx -= 1",
"+gy -= 1",
"+g = [list(eval(input())) for _ in range(h)]",
"+v = [[0 for j in range(w)] for i in range(h)]",
"+v2 = [[0 for j in range(w)] for i in range(h)]",
"+q = deque([])",
"+q.append([0, sx, sy])",
"+while q:",
"+ c, x, y = q.popleft()",
"+ if x == gx and y == gy:",
"+ print(c)",
"+ exit()",
"+ if v[x][y] == 1:",
"+ continue",
"+ v[x][y] = 1",
"+ for a in range(-2, 3):",
"+ for b in range(-2, 3):",
"+ if a == b == 0:",
"+ continue",
"+ if a * b == 0 and abs(a + b) == 1:",
"- q.append([nx, ny])",
"- v[nx][ny] = 1",
"- if len(l) == 0:",
"- break",
"- for x, y in l:",
"- for a in range(-2, 3):",
"- for b in range(-2, 3):",
"- if a * b == 0 and abs(a + b) <= 1:",
"- continue",
"- nx = x + a",
"- ny = y + b",
"- if (",
"- 0 <= nx < h",
"- and 0 <= ny < w",
"- and g[nx][ny] == \".\"",
"- and v[nx][ny] == 0",
"- ):",
"- q.append([nx, ny])",
"- v[nx][ny] = 1",
"- ans += 1",
"- print((-1))",
"-",
"-",
"-if __name__ == \"__main__\":",
"- main()",
"+ q.appendleft([c, nx, ny])",
"+ continue",
"+ nx = x + a",
"+ ny = y + b",
"+ if (",
"+ 0 <= nx < h",
"+ and 0 <= ny < w",
"+ and g[nx][ny] == \".\"",
"+ and v[nx][ny] == 0",
"+ and v2[nx][ny] == 0",
"+ ):",
"+ q.append([c + 1, nx, ny])",
"+ v2[nx][ny] = 1",
"+print((-1))"
] | false | 0.007757 | 0.039192 | 0.197924 |
[
"s809104787",
"s801576567"
] |
u780475861
|
p02839
|
python
|
s847399252
|
s966097096
| 309 | 65 | 29,932 | 20,468 |
Accepted
|
Accepted
| 78.96 |
import numpy as np
H, W = list(map(int, input().split()))
lst1 = []
lst2 = []
for _ in range(H):
lst1.append([int(i) for i in input().split()])
for _ in range(H):
lst2.append([int(i) for i in input().split()])
arr1, arr2 = np.array(lst1), np.array(lst2)
arr = np.abs(arr1 - arr2)
d = [[0] * W for _ in range(H)]
m = 80 * (H + W)
d[0][0] = 1 << m
for h in range(H):
for w in range(W):
x = arr[h][w]
if h > 0:
d[h][w] |= d[h - 1][w]
if w > 0:
d[h][w] |= d[h][w - 1]
d[h][w] = d[h][w] << x | d[h][w] >> x
x, y= 1 << m, 1 << m
for i in range(m + 1):
if d[H - 1][W - 1] & x or d[H - 1][W - 1] & y:
print(i)
quit()
x<<=1
y>>=1
|
H,W=list(map(int,input().split()))
A=[list(map(int,input().split())) for i in range(H)]
B=[list(map(int,input().split())) for i in range(H)]
d=[[0]*W for j in range(H)]
m=80*(H+W)
d[0][0]=1<<m
for h in range(H):
for w in range(W):
x=abs(A[h][w]-B[h][w])
if h>0:
d[h][w]|=d[h-1][w]
if w>0:
d[h][w]|=d[h][w-1]
d[h][w]=d[h][w]<<x|d[h][w]>>x
x,y=1<<m,1<<m
for i in range(99):
if d[H-1][W-1]&x or d[H-1][W-1]&y:
print(i)
exit()
x<<=1
y>>=1
| 31 | 21 | 743 | 537 |
import numpy as np
H, W = list(map(int, input().split()))
lst1 = []
lst2 = []
for _ in range(H):
lst1.append([int(i) for i in input().split()])
for _ in range(H):
lst2.append([int(i) for i in input().split()])
arr1, arr2 = np.array(lst1), np.array(lst2)
arr = np.abs(arr1 - arr2)
d = [[0] * W for _ in range(H)]
m = 80 * (H + W)
d[0][0] = 1 << m
for h in range(H):
for w in range(W):
x = arr[h][w]
if h > 0:
d[h][w] |= d[h - 1][w]
if w > 0:
d[h][w] |= d[h][w - 1]
d[h][w] = d[h][w] << x | d[h][w] >> x
x, y = 1 << m, 1 << m
for i in range(m + 1):
if d[H - 1][W - 1] & x or d[H - 1][W - 1] & y:
print(i)
quit()
x <<= 1
y >>= 1
|
H, W = list(map(int, input().split()))
A = [list(map(int, input().split())) for i in range(H)]
B = [list(map(int, input().split())) for i in range(H)]
d = [[0] * W for j in range(H)]
m = 80 * (H + W)
d[0][0] = 1 << m
for h in range(H):
for w in range(W):
x = abs(A[h][w] - B[h][w])
if h > 0:
d[h][w] |= d[h - 1][w]
if w > 0:
d[h][w] |= d[h][w - 1]
d[h][w] = d[h][w] << x | d[h][w] >> x
x, y = 1 << m, 1 << m
for i in range(99):
if d[H - 1][W - 1] & x or d[H - 1][W - 1] & y:
print(i)
exit()
x <<= 1
y >>= 1
| false | 32.258065 |
[
"-import numpy as np",
"-",
"-lst1 = []",
"-lst2 = []",
"-for _ in range(H):",
"- lst1.append([int(i) for i in input().split()])",
"-for _ in range(H):",
"- lst2.append([int(i) for i in input().split()])",
"-arr1, arr2 = np.array(lst1), np.array(lst2)",
"-arr = np.abs(arr1 - arr2)",
"-d = [[0] * W for _ in range(H)]",
"+A = [list(map(int, input().split())) for i in range(H)]",
"+B = [list(map(int, input().split())) for i in range(H)]",
"+d = [[0] * W for j in range(H)]",
"- x = arr[h][w]",
"+ x = abs(A[h][w] - B[h][w])",
"-for i in range(m + 1):",
"+for i in range(99):",
"- quit()",
"+ exit()"
] | false | 0.925566 | 0.084924 | 10.898739 |
[
"s847399252",
"s966097096"
] |
u877470159
|
p03682
|
python
|
s861389371
|
s197742069
| 1,566 | 1,392 | 119,900 | 108,124 |
Accepted
|
Accepted
| 11.11 |
import sys
input=sys.stdin.readline
n=int(eval(input()))
pointx=[]
pointy=[]
for i in range(n):
x,y=list(map(int,input().split()))
pointx.append((x,i))
pointy.append((y,i))
pointx.sort()
pointy.sort()
G=[[] for i in range(n)]
for i in range(n-1):
dx=abs(pointx[i+1][0]-pointx[i][0])
G[pointx[i][1]].append((dx,pointx[i+1][1]))
G[pointx[i+1][1]].append((dx,pointx[i][1]))
dy=abs(pointy[i+1][0]-pointy[i][0])
G[pointy[i][1]].append((dy,pointy[i+1][1]))
G[pointy[i+1][1]].append((dy,pointy[i][1]))
import heapq
q=[]
check=[False]*n
check[0]=True
for i in G[0]:
heapq.heappush(q,i)
ans=0
while len(q)>0:
now=heapq.heappop(q)
if not check[now[1]]:
ans+=now[0]
check[now[1]]=True
for i in G[now[1]]:
heapq.heappush(q,i)
print(ans)
|
import sys
input=sys.stdin.readline
n=int(eval(input()))
pointx=[]
pointy=[]
for i in range(n):
x,y=list(map(int,input().split()))
pointx.append((x,i))
pointy.append((y,i))
pointx.sort()
pointy.sort()
G=[[] for i in range(n)]
for i in range(n-1):
dx=abs(pointx[i+1][0]-pointx[i][0])
G[pointx[i][1]].append((dx,pointx[i+1][1]))
G[pointx[i+1][1]].append((dx,pointx[i][1]))
dy=abs(pointy[i+1][0]-pointy[i][0])
G[pointy[i][1]].append((dy,pointy[i+1][1]))
G[pointy[i+1][1]].append((dy,pointy[i][1]))
import heapq
q=[]
check=[False]*n
INF=10**10
d=[INF]*n
ans=0
d[0]=0
heapq.heappush(q,(0,0))
while len(q)>0:
now=heapq.heappop(q)
if not check[now[1]]:
ans+=now[0]
check[now[1]]=True
for i in G[now[1]]:
if i[0]<d[i[1]]:
d[i[1]]=i[0]
heapq.heappush(q,i)
print(ans)
| 36 | 39 | 834 | 898 |
import sys
input = sys.stdin.readline
n = int(eval(input()))
pointx = []
pointy = []
for i in range(n):
x, y = list(map(int, input().split()))
pointx.append((x, i))
pointy.append((y, i))
pointx.sort()
pointy.sort()
G = [[] for i in range(n)]
for i in range(n - 1):
dx = abs(pointx[i + 1][0] - pointx[i][0])
G[pointx[i][1]].append((dx, pointx[i + 1][1]))
G[pointx[i + 1][1]].append((dx, pointx[i][1]))
dy = abs(pointy[i + 1][0] - pointy[i][0])
G[pointy[i][1]].append((dy, pointy[i + 1][1]))
G[pointy[i + 1][1]].append((dy, pointy[i][1]))
import heapq
q = []
check = [False] * n
check[0] = True
for i in G[0]:
heapq.heappush(q, i)
ans = 0
while len(q) > 0:
now = heapq.heappop(q)
if not check[now[1]]:
ans += now[0]
check[now[1]] = True
for i in G[now[1]]:
heapq.heappush(q, i)
print(ans)
|
import sys
input = sys.stdin.readline
n = int(eval(input()))
pointx = []
pointy = []
for i in range(n):
x, y = list(map(int, input().split()))
pointx.append((x, i))
pointy.append((y, i))
pointx.sort()
pointy.sort()
G = [[] for i in range(n)]
for i in range(n - 1):
dx = abs(pointx[i + 1][0] - pointx[i][0])
G[pointx[i][1]].append((dx, pointx[i + 1][1]))
G[pointx[i + 1][1]].append((dx, pointx[i][1]))
dy = abs(pointy[i + 1][0] - pointy[i][0])
G[pointy[i][1]].append((dy, pointy[i + 1][1]))
G[pointy[i + 1][1]].append((dy, pointy[i][1]))
import heapq
q = []
check = [False] * n
INF = 10**10
d = [INF] * n
ans = 0
d[0] = 0
heapq.heappush(q, (0, 0))
while len(q) > 0:
now = heapq.heappop(q)
if not check[now[1]]:
ans += now[0]
check[now[1]] = True
for i in G[now[1]]:
if i[0] < d[i[1]]:
d[i[1]] = i[0]
heapq.heappush(q, i)
print(ans)
| false | 7.692308 |
[
"-check[0] = True",
"-for i in G[0]:",
"- heapq.heappush(q, i)",
"+INF = 10**10",
"+d = [INF] * n",
"+d[0] = 0",
"+heapq.heappush(q, (0, 0))",
"- heapq.heappush(q, i)",
"+ if i[0] < d[i[1]]:",
"+ d[i[1]] = i[0]",
"+ heapq.heappush(q, i)"
] | false | 0.039601 | 0.039244 | 1.009087 |
[
"s861389371",
"s197742069"
] |
u366369712
|
p03266
|
python
|
s631532050
|
s086564225
| 197 | 64 | 52,080 | 3,060 |
Accepted
|
Accepted
| 67.51 |
n,k = list(map(int,input().split()))
if k%2 == 1:
cnts = []
for i in range(1,n+1):
if i % k == 0:
cnts.append(i)
print((len(cnts)**3))
else:
k0 = 0
k1 = 0
for i in range(1,n+1):
if i % k == 0:
k0 += 1
elif i %k == k//2:
k1 += 1
print((k0**3 + k1**3))
|
n,k = list(map(int,input().split()))
a = 0
a2 = 0
for i in range(1,n+1):
if i % k == 0:
a += 1
elif 2*i % k == 0:
a2 += 1
print((a**3 + a2**3))
| 17 | 9 | 345 | 167 |
n, k = list(map(int, input().split()))
if k % 2 == 1:
cnts = []
for i in range(1, n + 1):
if i % k == 0:
cnts.append(i)
print((len(cnts) ** 3))
else:
k0 = 0
k1 = 0
for i in range(1, n + 1):
if i % k == 0:
k0 += 1
elif i % k == k // 2:
k1 += 1
print((k0**3 + k1**3))
|
n, k = list(map(int, input().split()))
a = 0
a2 = 0
for i in range(1, n + 1):
if i % k == 0:
a += 1
elif 2 * i % k == 0:
a2 += 1
print((a**3 + a2**3))
| false | 47.058824 |
[
"-if k % 2 == 1:",
"- cnts = []",
"- for i in range(1, n + 1):",
"- if i % k == 0:",
"- cnts.append(i)",
"- print((len(cnts) ** 3))",
"-else:",
"- k0 = 0",
"- k1 = 0",
"- for i in range(1, n + 1):",
"- if i % k == 0:",
"- k0 += 1",
"- elif i % k == k // 2:",
"- k1 += 1",
"- print((k0**3 + k1**3))",
"+a = 0",
"+a2 = 0",
"+for i in range(1, n + 1):",
"+ if i % k == 0:",
"+ a += 1",
"+ elif 2 * i % k == 0:",
"+ a2 += 1",
"+print((a**3 + a2**3))"
] | false | 0.040149 | 0.038409 | 1.045287 |
[
"s631532050",
"s086564225"
] |
u564902833
|
p02982
|
python
|
s817803687
|
s036196984
| 184 | 18 | 39,664 | 3,060 |
Accepted
|
Accepted
| 90.22 |
N, D = list(map(int, input().split()))
X = []
for _ in range(N):
X.append([int(x) for x in input().split()])
ans = 0
for i in range(N - 1):
for j in range(i + 1, N):
s = sum((X[i][d] - X[j][d])**2 for d in range(D))
if any(i**2 == s for i in range(1000)):
ans += 1
print(ans)
|
N, D = list(map(int, input().split()))
X = [list(map(int, input().split())) for _ in range(N)]
S = {i**2 for i in range(1000)}
ans = sum(
a != b and sum((x - y)**2 for x, y in zip(a, b)) in S
for a in X
for b in X
) // 2
print(ans)
| 12 | 11 | 318 | 250 |
N, D = list(map(int, input().split()))
X = []
for _ in range(N):
X.append([int(x) for x in input().split()])
ans = 0
for i in range(N - 1):
for j in range(i + 1, N):
s = sum((X[i][d] - X[j][d]) ** 2 for d in range(D))
if any(i**2 == s for i in range(1000)):
ans += 1
print(ans)
|
N, D = list(map(int, input().split()))
X = [list(map(int, input().split())) for _ in range(N)]
S = {i**2 for i in range(1000)}
ans = (
sum(a != b and sum((x - y) ** 2 for x, y in zip(a, b)) in S for a in X for b in X)
// 2
)
print(ans)
| false | 8.333333 |
[
"-X = []",
"-for _ in range(N):",
"- X.append([int(x) for x in input().split()])",
"-ans = 0",
"-for i in range(N - 1):",
"- for j in range(i + 1, N):",
"- s = sum((X[i][d] - X[j][d]) ** 2 for d in range(D))",
"- if any(i**2 == s for i in range(1000)):",
"- ans += 1",
"+X = [list(map(int, input().split())) for _ in range(N)]",
"+S = {i**2 for i in range(1000)}",
"+ans = (",
"+ sum(a != b and sum((x - y) ** 2 for x, y in zip(a, b)) in S for a in X for b in X)",
"+ // 2",
"+)"
] | false | 0.040296 | 0.042082 | 0.957555 |
[
"s817803687",
"s036196984"
] |
u133936772
|
p03103
|
python
|
s479429841
|
s283077484
| 533 | 210 | 27,752 | 25,828 |
Accepted
|
Accepted
| 60.6 |
f=lambda:list(map(int,input().split()));n,m=f();c=0
for a,b in sorted(list(f())for _ in range(n)):t=min(b,m);c+=a*t;m-=t
print(c)
|
n,m,*l=list(map(int,open(0).read().split()));c=0
for a,b in sorted(zip(*[iter(l)]*2)):t=min(b,m);c+=a*t;m-=t
print(c)
| 3 | 3 | 125 | 113 |
f = lambda: list(map(int, input().split()))
n, m = f()
c = 0
for a, b in sorted(list(f()) for _ in range(n)):
t = min(b, m)
c += a * t
m -= t
print(c)
|
n, m, *l = list(map(int, open(0).read().split()))
c = 0
for a, b in sorted(zip(*[iter(l)] * 2)):
t = min(b, m)
c += a * t
m -= t
print(c)
| false | 0 |
[
"-f = lambda: list(map(int, input().split()))",
"-n, m = f()",
"+n, m, *l = list(map(int, open(0).read().split()))",
"-for a, b in sorted(list(f()) for _ in range(n)):",
"+for a, b in sorted(zip(*[iter(l)] * 2)):"
] | false | 0.108413 | 0.104227 | 1.04016 |
[
"s479429841",
"s283077484"
] |
u645250356
|
p02802
|
python
|
s005829374
|
s338760787
| 609 | 213 | 93,780 | 81,464 |
Accepted
|
Accepted
| 65.02 |
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
import sys,bisect,math,itertools,pprint,fractions
sys.setrecursionlimit(10**8)
mod = 10**9+7
mod2 = 998244353
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpln(n): return list(int(sys.stdin.readline()) for i in range(n))
n,m = inpl()
sc = [input().split() for i in range(m)]
ac = 0
pena = 0
stpe = [0] * (n+1)
prob = [False] * (n+1)
for s,c in sc:
s = int(s)
if prob[s]:
continue
else:
if c == 'AC':
prob[s] = True
ac += 1
pena += stpe[s]
stpe[s] = 0
else:
stpe[s] += 1
print((ac,pena))
|
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush
from bisect import bisect_left,bisect_right
import sys,math,itertools,fractions,pprint
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
n,m = inpl()
a = [False] * (n+1)
cnt = [0] * (n+1)
for _ in range(m):
x,y = input().split()
x = int(x)
if y == 'AC':
a[x] = True
else:
if not a[x]:
cnt[x] += 1
pena = 0
for i in range(1,n+1):
if a[i]: pena += cnt[i]
print((sum(a), pena))
| 30 | 25 | 790 | 651 |
from collections import Counter, defaultdict, deque
from heapq import heappop, heappush, heapify
import sys, bisect, math, itertools, pprint, fractions
sys.setrecursionlimit(10**8)
mod = 10**9 + 7
mod2 = 998244353
INF = float("inf")
def inp():
return int(sys.stdin.readline())
def inpl():
return list(map(int, sys.stdin.readline().split()))
def inpln(n):
return list(int(sys.stdin.readline()) for i in range(n))
n, m = inpl()
sc = [input().split() for i in range(m)]
ac = 0
pena = 0
stpe = [0] * (n + 1)
prob = [False] * (n + 1)
for s, c in sc:
s = int(s)
if prob[s]:
continue
else:
if c == "AC":
prob[s] = True
ac += 1
pena += stpe[s]
stpe[s] = 0
else:
stpe[s] += 1
print((ac, pena))
|
from collections import Counter, defaultdict, deque
from heapq import heappop, heappush
from bisect import bisect_left, bisect_right
import sys, math, itertools, fractions, pprint
sys.setrecursionlimit(10**8)
mod = 10**9 + 7
INF = float("inf")
def inp():
return int(sys.stdin.readline())
def inpl():
return list(map(int, sys.stdin.readline().split()))
n, m = inpl()
a = [False] * (n + 1)
cnt = [0] * (n + 1)
for _ in range(m):
x, y = input().split()
x = int(x)
if y == "AC":
a[x] = True
else:
if not a[x]:
cnt[x] += 1
pena = 0
for i in range(1, n + 1):
if a[i]:
pena += cnt[i]
print((sum(a), pena))
| false | 16.666667 |
[
"-from heapq import heappop, heappush, heapify",
"-import sys, bisect, math, itertools, pprint, fractions",
"+from heapq import heappop, heappush",
"+from bisect import bisect_left, bisect_right",
"+import sys, math, itertools, fractions, pprint",
"-mod2 = 998244353",
"-def inpln(n):",
"- return list(int(sys.stdin.readline()) for i in range(n))",
"-",
"-",
"-sc = [input().split() for i in range(m)]",
"-ac = 0",
"+a = [False] * (n + 1)",
"+cnt = [0] * (n + 1)",
"+for _ in range(m):",
"+ x, y = input().split()",
"+ x = int(x)",
"+ if y == \"AC\":",
"+ a[x] = True",
"+ else:",
"+ if not a[x]:",
"+ cnt[x] += 1",
"-stpe = [0] * (n + 1)",
"-prob = [False] * (n + 1)",
"-for s, c in sc:",
"- s = int(s)",
"- if prob[s]:",
"- continue",
"- else:",
"- if c == \"AC\":",
"- prob[s] = True",
"- ac += 1",
"- pena += stpe[s]",
"- stpe[s] = 0",
"- else:",
"- stpe[s] += 1",
"-print((ac, pena))",
"+for i in range(1, n + 1):",
"+ if a[i]:",
"+ pena += cnt[i]",
"+print((sum(a), pena))"
] | false | 0.098456 | 0.070068 | 1.405146 |
[
"s005829374",
"s338760787"
] |
u269969976
|
p03386
|
python
|
s085727219
|
s111554607
| 20 | 17 | 3,316 | 3,060 |
Accepted
|
Accepted
| 15 |
# -*- coding: utf-8 -*-
(a, b, k) = [int(i) for i in input().rstrip().split(" ")]
target = set([i for i in range(a, a+k)]).union([i for i in range(b-k+1, b+1)])
target = sorted([i for i in target if a <= i <= b])
for i in target:
print(i)
|
# coding: utf-8
(a,b,k) = list(map(int, input().rstrip().split(" ")))
ans = []
for i in range(a, min(b+1,a+k)):
ans.append(i)
for i in range(max(a, b-k+1), b+1):
ans.append(i)
for i in sorted(set(ans)):
print(i)
| 7 | 15 | 249 | 238 |
# -*- coding: utf-8 -*-
(a, b, k) = [int(i) for i in input().rstrip().split(" ")]
target = set([i for i in range(a, a + k)]).union([i for i in range(b - k + 1, b + 1)])
target = sorted([i for i in target if a <= i <= b])
for i in target:
print(i)
|
# coding: utf-8
(a, b, k) = list(map(int, input().rstrip().split(" ")))
ans = []
for i in range(a, min(b + 1, a + k)):
ans.append(i)
for i in range(max(a, b - k + 1), b + 1):
ans.append(i)
for i in sorted(set(ans)):
print(i)
| false | 53.333333 |
[
"-# -*- coding: utf-8 -*-",
"-(a, b, k) = [int(i) for i in input().rstrip().split(\" \")]",
"-target = set([i for i in range(a, a + k)]).union([i for i in range(b - k + 1, b + 1)])",
"-target = sorted([i for i in target if a <= i <= b])",
"-for i in target:",
"+# coding: utf-8",
"+(a, b, k) = list(map(int, input().rstrip().split(\" \")))",
"+ans = []",
"+for i in range(a, min(b + 1, a + k)):",
"+ ans.append(i)",
"+for i in range(max(a, b - k + 1), b + 1):",
"+ ans.append(i)",
"+for i in sorted(set(ans)):"
] | false | 0.049083 | 0.04928 | 0.995996 |
[
"s085727219",
"s111554607"
] |
u334712262
|
p02695
|
python
|
s246342812
|
s918110910
| 313 | 150 | 81,628 | 67,712 |
Accepted
|
Accepted
| 52.08 |
# -*- coding: utf-8 -*-
# sys.setrecursionlimit(100000)
INF = 2**62-1
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def slv(N, M, Q, ABCD):
def dfs(a, n):
r = 0
if n == N:
t = 0
for abcd in ABCD:
A, B, C, D = abcd
if a[B] - a[A] == C:
t += D
return t
b = a[-1]
for c in range(b, M+1):
a.append(c)
r = max(r, dfs(a, n+1))
a.pop()
return r
return dfs([1], 0)
def main():
N, M, Q = read_int_n()
ABCD = [read_int_n() for _ in range(Q)]
print(slv(N, M, Q, ABCD))
if __name__ == '__main__':
main()
|
# -*- coding: utf-8 -*-
from itertools import combinations_with_replacement
def read_int_n():
return list(map(int, input().split()))
def slv(N, M, Q, ABCD):
ans = 0
for a in combinations_with_replacement(list(range(1, M+1)), r=N):
t = 0
for abcd in ABCD:
A, B, C, D = abcd
if a[B-1] - a[A-1] == C:
t += D
ans = max(ans, t)
return ans
def main():
N, M, Q = read_int_n()
ABCD = [read_int_n() for _ in range(Q)]
print((slv(N, M, Q, ABCD)))
if __name__ == '__main__':
main()
| 60 | 28 | 1,085 | 594 |
# -*- coding: utf-8 -*-
# sys.setrecursionlimit(100000)
INF = 2**62 - 1
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def slv(N, M, Q, ABCD):
def dfs(a, n):
r = 0
if n == N:
t = 0
for abcd in ABCD:
A, B, C, D = abcd
if a[B] - a[A] == C:
t += D
return t
b = a[-1]
for c in range(b, M + 1):
a.append(c)
r = max(r, dfs(a, n + 1))
a.pop()
return r
return dfs([1], 0)
def main():
N, M, Q = read_int_n()
ABCD = [read_int_n() for _ in range(Q)]
print(slv(N, M, Q, ABCD))
if __name__ == "__main__":
main()
|
# -*- coding: utf-8 -*-
from itertools import combinations_with_replacement
def read_int_n():
return list(map(int, input().split()))
def slv(N, M, Q, ABCD):
ans = 0
for a in combinations_with_replacement(list(range(1, M + 1)), r=N):
t = 0
for abcd in ABCD:
A, B, C, D = abcd
if a[B - 1] - a[A - 1] == C:
t += D
ans = max(ans, t)
return ans
def main():
N, M, Q = read_int_n()
ABCD = [read_int_n() for _ in range(Q)]
print((slv(N, M, Q, ABCD)))
if __name__ == "__main__":
main()
| false | 53.333333 |
[
"-# sys.setrecursionlimit(100000)",
"-INF = 2**62 - 1",
"-",
"-",
"-def read_int():",
"- return int(input())",
"+from itertools import combinations_with_replacement",
"-def read_float():",
"- return float(input())",
"-",
"-",
"-def read_float_n():",
"- return list(map(float, input().split()))",
"-",
"-",
"-def read_str():",
"- return input().strip()",
"-",
"-",
"-def read_str_n():",
"- return list(map(str, input().split()))",
"-",
"-",
"-def error_print(*args):",
"- print(*args, file=sys.stderr)",
"-",
"-",
"- def dfs(a, n):",
"- r = 0",
"- if n == N:",
"- t = 0",
"- for abcd in ABCD:",
"- A, B, C, D = abcd",
"- if a[B] - a[A] == C:",
"- t += D",
"- return t",
"- b = a[-1]",
"- for c in range(b, M + 1):",
"- a.append(c)",
"- r = max(r, dfs(a, n + 1))",
"- a.pop()",
"- return r",
"-",
"- return dfs([1], 0)",
"+ ans = 0",
"+ for a in combinations_with_replacement(list(range(1, M + 1)), r=N):",
"+ t = 0",
"+ for abcd in ABCD:",
"+ A, B, C, D = abcd",
"+ if a[B - 1] - a[A - 1] == C:",
"+ t += D",
"+ ans = max(ans, t)",
"+ return ans",
"- print(slv(N, M, Q, ABCD))",
"+ print((slv(N, M, Q, ABCD)))"
] | false | 0.097815 | 0.042196 | 2.318131 |
[
"s246342812",
"s918110910"
] |
u124498235
|
p02803
|
python
|
s313320000
|
s993497891
| 616 | 538 | 3,188 | 3,316 |
Accepted
|
Accepted
| 12.66 |
h, w = list(map(int, input().split()))
s = []
for i in range(h):
ss = eval(input())
s.append(ss)
dx = [1,0,-1,0]
dy = [0,1,0,-1]
ans = 0
for i in range(h):
for j in range(w):
if s[i][j] == "#":
continue
visited = [[0 for ii in range(w)] for jj in range(h) ]
st = [[i,j]]
visited[i][j] = 1
while st:
x,y = st.pop(0)
for k in range(4):
p = x + dx[k]
q = y + dy[k]
if p < 0 or q < 0 or p >= h or q >= w or s[p][q] == "#" or visited[p][q] != 0:
continue
st.append([p,q])
visited[p][q] = visited[x][y] + 1
#print (visited)
for a in range(h):
for b in range(w):
ans = max(ans,visited[a][b])
print((ans-1))
|
from collections import deque
h, w = list(map(int, input().split()))
s = []
for i in range(h):
t = eval(input())
s.append(t)
res = 0
dx = [1,0,-1,0]
dy = [0,1,0,-1]
for i in range(h):
for j in range(w):
if s[i][j] == "#":
continue
queue = deque([[i,j]])
visited = [[0 for ii in range(w)] for jj in range(h)]
visited[i][j] = 1
while queue:
l,m = queue.popleft()
for k in range(4):
x = l + dx[k]
y = m + dy[k]
if x < 0 or y < 0 or x >= h or y >= w or visited[x][y] != 0 or s[x][y] == "#":
continue
visited[x][y] = visited[l][m] + 1
queue.append([x,y])
for ii in range(h):
for jj in range(w):
res = max(res,visited[ii][jj])
print((res-1))
| 30 | 30 | 674 | 708 |
h, w = list(map(int, input().split()))
s = []
for i in range(h):
ss = eval(input())
s.append(ss)
dx = [1, 0, -1, 0]
dy = [0, 1, 0, -1]
ans = 0
for i in range(h):
for j in range(w):
if s[i][j] == "#":
continue
visited = [[0 for ii in range(w)] for jj in range(h)]
st = [[i, j]]
visited[i][j] = 1
while st:
x, y = st.pop(0)
for k in range(4):
p = x + dx[k]
q = y + dy[k]
if (
p < 0
or q < 0
or p >= h
or q >= w
or s[p][q] == "#"
or visited[p][q] != 0
):
continue
st.append([p, q])
visited[p][q] = visited[x][y] + 1
# print (visited)
for a in range(h):
for b in range(w):
ans = max(ans, visited[a][b])
print((ans - 1))
|
from collections import deque
h, w = list(map(int, input().split()))
s = []
for i in range(h):
t = eval(input())
s.append(t)
res = 0
dx = [1, 0, -1, 0]
dy = [0, 1, 0, -1]
for i in range(h):
for j in range(w):
if s[i][j] == "#":
continue
queue = deque([[i, j]])
visited = [[0 for ii in range(w)] for jj in range(h)]
visited[i][j] = 1
while queue:
l, m = queue.popleft()
for k in range(4):
x = l + dx[k]
y = m + dy[k]
if (
x < 0
or y < 0
or x >= h
or y >= w
or visited[x][y] != 0
or s[x][y] == "#"
):
continue
visited[x][y] = visited[l][m] + 1
queue.append([x, y])
for ii in range(h):
for jj in range(w):
res = max(res, visited[ii][jj])
print((res - 1))
| false | 0 |
[
"+from collections import deque",
"+",
"- ss = eval(input())",
"- s.append(ss)",
"+ t = eval(input())",
"+ s.append(t)",
"+res = 0",
"-ans = 0",
"+ queue = deque([[i, j]])",
"- st = [[i, j]]",
"- while st:",
"- x, y = st.pop(0)",
"+ while queue:",
"+ l, m = queue.popleft()",
"- p = x + dx[k]",
"- q = y + dy[k]",
"+ x = l + dx[k]",
"+ y = m + dy[k]",
"- p < 0",
"- or q < 0",
"- or p >= h",
"- or q >= w",
"- or s[p][q] == \"#\"",
"- or visited[p][q] != 0",
"+ x < 0",
"+ or y < 0",
"+ or x >= h",
"+ or y >= w",
"+ or visited[x][y] != 0",
"+ or s[x][y] == \"#\"",
"- st.append([p, q])",
"- visited[p][q] = visited[x][y] + 1",
"- # print (visited)",
"- for a in range(h):",
"- for b in range(w):",
"- ans = max(ans, visited[a][b])",
"-print((ans - 1))",
"+ visited[x][y] = visited[l][m] + 1",
"+ queue.append([x, y])",
"+ for ii in range(h):",
"+ for jj in range(w):",
"+ res = max(res, visited[ii][jj])",
"+print((res - 1))"
] | false | 0.043511 | 0.036806 | 1.182177 |
[
"s313320000",
"s993497891"
] |
u040298438
|
p03106
|
python
|
s507830047
|
s369685149
| 30 | 26 | 9,184 | 8,964 |
Accepted
|
Accepted
| 13.33 |
temp = []
l = []
a, b, k = list(map(int, input().split()))
for i in range(1, a + 1):
if a % i == 0:
temp.append(i)
for i in range(1, b + 1):
if b % i == 0 and i in temp:
l.append(i)
print((l[k * -1]))
|
a, b, k = list(map(int, input().split()))
l = [i for i in range(1, min(a, b) + 1) if not (a % i or b % i)]
print((l[-k]))
| 13 | 3 | 231 | 116 |
temp = []
l = []
a, b, k = list(map(int, input().split()))
for i in range(1, a + 1):
if a % i == 0:
temp.append(i)
for i in range(1, b + 1):
if b % i == 0 and i in temp:
l.append(i)
print((l[k * -1]))
|
a, b, k = list(map(int, input().split()))
l = [i for i in range(1, min(a, b) + 1) if not (a % i or b % i)]
print((l[-k]))
| false | 76.923077 |
[
"-temp = []",
"-l = []",
"-for i in range(1, a + 1):",
"- if a % i == 0:",
"- temp.append(i)",
"-for i in range(1, b + 1):",
"- if b % i == 0 and i in temp:",
"- l.append(i)",
"-print((l[k * -1]))",
"+l = [i for i in range(1, min(a, b) + 1) if not (a % i or b % i)]",
"+print((l[-k]))"
] | false | 0.038579 | 0.036942 | 1.04432 |
[
"s507830047",
"s369685149"
] |
u363610900
|
p03777
|
python
|
s054862573
|
s011624851
| 19 | 17 | 2,940 | 2,940 |
Accepted
|
Accepted
| 10.53 |
a, b = input().split()
print(('H' if a == b else 'D'))
|
a, b = input().split()
print(('H' if a == 'H' and b == 'H'or a == 'D' and b == 'D' else 'D'))
| 2 | 2 | 53 | 92 |
a, b = input().split()
print(("H" if a == b else "D"))
|
a, b = input().split()
print(("H" if a == "H" and b == "H" or a == "D" and b == "D" else "D"))
| false | 0 |
[
"-print((\"H\" if a == b else \"D\"))",
"+print((\"H\" if a == \"H\" and b == \"H\" or a == \"D\" and b == \"D\" else \"D\"))"
] | false | 0.149581 | 0.0467 | 3.203025 |
[
"s054862573",
"s011624851"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.