problem_id
stringlengths 6
6
| buggy_code
stringlengths 8
526k
⌀ | fixed_code
stringlengths 12
526k
⌀ | labels
listlengths 0
15
⌀ | buggy_submission_id
int64 1
1.54M
⌀ | fixed_submission_id
int64 2
1.54M
⌀ | user_id
stringlengths 10
10
⌀ | language
stringclasses 9
values |
|---|---|---|---|---|---|---|---|
p02780
|
#!/usr/bin/env python3
def calcExpectedValue(prob):
return (prob+1)/2
def solve(n,k,p):
expLst = [calcExpectedValue(prob) for prob in p]
cum = [0]*(n+1)
for i in range(n):
cum[i+1] = cum[i] + expLst[i]
ans = 0
i = 0
while i+k < n:
ans = max(ans,cum[i+k]-cum[i])
i += 1
return ans
def main():
N,K = map(int,input().split())
p = list(map(int,input().split()))
print(solve(N,K,p))
return
if __name__ == '__main__':
main()
|
#!/usr/bin/env python3
def calcExpectedValue(prob):
return (prob+1)/2
def solve(n,k,p):
expLst = [calcExpectedValue(prob) for prob in p]
cum = [0]*(n+1)
for i in range(n):
cum[i+1] = cum[i] + expLst[i]
ans = 0
i = 0
while i+k <= n:
ans = max(ans,cum[i+k]-cum[i])
i += 1
return ans
def main():
N,K = map(int,input().split())
p = list(map(int,input().split()))
print(solve(N,K,p))
return
if __name__ == '__main__':
main()
|
[
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 579,326
| 579,327
|
u425762225
|
python
|
p02780
|
n, k = map( int, input().split() )
p = list( map( int, input().split() ) )
sum_k = sum( p[ : k ] )
max_sum_k = 0
for i in range( k, n ):
sum_k += p[ i ] - p[ i - k ]
if sum_k > max_sum_k:
max_sum_k = sum_k
print( ( max_sum_k + k ) / 2 )
|
n, k = map( int, input().split() )
p = list( map( int, input().split() ) )
sum_k = sum( p[ : k ] )
max_sum_k = sum_k
for i in range( k, n ):
sum_k += p[ i ] - p[ i - k ]
if sum_k > max_sum_k:
max_sum_k = sum_k
print( ( max_sum_k + k ) / 2 )
|
[
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 579,345
| 579,346
|
u836004075
|
python
|
p02780
|
from itertools import accumulate
N, K = list(map(int, input().split()))
P = list(map(lambda x: int(x) + 1, input().split()))
P_cumsum = list(accumulate(P))
print(max([P_cumsum[i+K]-P_cumsum[i] for i in range(N-K)])/2)
|
from itertools import accumulate
N, K = list(map(int, input().split()))
P = list(map(lambda x: int(x) + 1, input().split()))
P_cumsum = [0] + list(accumulate(P))
print(max([P_cumsum[i+K]-P_cumsum[i] for i in range(N-K+1)])/2)
|
[
"assignment.change",
"control_flow.loop.range.bounds.upper.change",
"expression.operation.binary.add"
] | 579,361
| 579,362
|
u633255271
|
python
|
p02780
|
n, k = map(int, input().split())
def kitai(x):
return (1+int(x))/2
p = list(map(kitai, input().split()))
pre = psum = sum(p[0:k])
for i in range(n):
if i+k > n:
break
pre = pre - p[i-1] + p[i+k-1]
psum = max(psum, pre)
print(psum)
|
n, k = map(int, input().split())
def kitai(x):
return (1+int(x))/2
p = list(map(kitai, input().split()))
pre = psum = sum(p[0:k])
for i in range(1, n):
if i+k > n:
break
pre = pre - p[i-1] + p[i+k-1]
psum = max(psum, pre)
print(psum)
|
[
"call.arguments.add"
] | 579,363
| 579,364
|
u088552457
|
python
|
p02780
|
n, k = map(int, input().split())
p = list(map(int, input().split()))
for i in range(n):
p[i] = (p[i] + 1) / 2
ans = sum(p[:k])
pre = sum(p[:k])
print(p)
for j in range(k, n):
pre = pre + p[j]- p[j - k]
ans = max(ans, pre)
print(ans)
|
n, k = map(int, input().split())
p = list(map(int, input().split()))
for i in range(n):
p[i] = (p[i] + 1) / 2
ans = sum(p[:k])
pre = sum(p[:k])
for j in range(k, n):
pre = pre + p[j]- p[j - k]
ans = max(ans, pre)
print(ans)
|
[
"call.remove"
] | 579,369
| 579,370
|
u051928503
|
python
|
p02780
|
N, K = map(int, input().split(' '))
P = tuple(map(int, input().split(' ')))
values = [0]
for p in P:
values.append(values[-1] + (p * (p + 1) // 2 / p))
ans = 0
for i in range(K, N):
ans = max(ans, values[i + 1] - values[i - K + 1])
print(ans)
|
N, K = map(int, input().split(' '))
P = tuple(map(int, input().split(' ')))
values = [0]
for p in P:
values.append(values[-1] + (p * (p + 1) // 2 / p))
ans = 0
for i in range(K, N + 1):
ans = max(ans, values[i] - values[i - K])
print(ans)
|
[
"expression.operation.binary.remove"
] | 579,371
| 579,372
|
u606878291
|
python
|
p02780
|
a,b=map(int, input().split())
c=list(map(int, input().split()))
l =[]
ans = 0
def abc(n):
return (n+1)/2
cb = list(map(abc,c))
s = sum(cb[:b])
l.append(s)
for i in range(b,a+1):
s = s - cb[i-b] + cb[b]
l.append(s)
L = sorted(l)
print(L[-1])
|
a,b=map(int, input().split())
c=list(map(int, input().split()))
l =[]
ans = 0
def abc(n):
return (n+1)/2
cb = list(map(abc,c))
s = sum(cb[:b])
l.append(s)
for i in range(b,a):
s = s - cb[i-b] + cb[i]
l.append(s)
L = sorted(l)
print(L[-1])
|
[
"expression.operation.binary.remove",
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 579,377
| 579,378
|
u814271993
|
python
|
p02780
|
N, K = map(int, input().split())
p = list(map(int, input().split()))
ans = [sum(p[:K])]
for i in range(N-K):
ans.append(ans[-1]-p[i]+p[i+k])
print(max(ans)/2+K/2)
|
N, K = map(int, input().split())
p = list(map(int, input().split()))
ans = [sum(p[:K])]
for i in range(N-K):
ans.append(ans[-1]-p[i]+p[i+K])
print(max(ans)/2+K/2)
|
[
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 579,387
| 579,388
|
u829416877
|
python
|
p02780
|
import sys
from itertools import accumulate
rm = lambda: map(int, sys.stdin.readline().split())
rl = lambda: list(map(int, sys.stdin.readline().split()))
n, k = rm()
a = [(i+1)/2 for i in rl()]
a = list(accumulate(a))
ans = 0
for i in range(n-k):
ans = max(ans, a[i+k] - a[i])
print(ans)
|
import sys
from itertools import accumulate
rm = lambda: map(int, sys.stdin.readline().split())
rl = lambda: list(map(int, sys.stdin.readline().split()))
n, k = rm()
a = [(i+1)/2 for i in rl()]
a = [0] + list(accumulate(a))
ans = 0
for i in range(n-k+1):
ans = max(ans, a[i+k] - a[i])
print(ans)
|
[
"assignment.change",
"control_flow.loop.range.bounds.upper.change",
"expression.operation.binary.add"
] | 579,391
| 579,392
|
u823885866
|
python
|
p02780
|
N, K = map(int, input().split())
p = list(map(int, input().split()))
a = 0
for i in range(N - K + 1):
if i == 0:
f = i
b = sum(p[0:K])
else:
b = a - p[i-1] + p[i + K - 1]
if b > a:
a = b
f = i
ans = 0
for j in range(K):
ans += (p[f + j] + 1) / 2
print(ans)
|
N, K = map(int, input().split())
p = list(map(int, input().split()))
a = 0
for i in range(N - K + 1):
if i == 0:
b = sum(p[0:K])
else:
b = b - p[i-1] + p[i + K - 1]
if b > a:
a = b
f = i
ans = 0
for j in range(K):
ans += (p[f + j] + 1) / 2
print(ans)
|
[
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 579,407
| 579,408
|
u241159583
|
python
|
p02780
|
#python3
def f(x):
return (x+1)/2
def main():
n, k = map(int, input().split())
fp = [f(int(i)) for i in input().split()]
n = len(fp)
v = sum(fp[0:k])
i = 0
ans = 0
while i+k <= n-1:
v = v-fp[i]+fp[i+k]
ans = max(ans, v)
i+=1
a = "{0:.12f}".format(ans)
print(a)
main()
|
#python3
def f(x):
return (x+1)/2
def main():
n, k = map(int, input().split())
fp = [f(int(i)) for i in input().split()]
n = len(fp)
v = sum(fp[0:k])
i = 0
ans = v
while i+k <= n-1:
v = v-fp[i]+fp[i+k]
ans = max(ans, v)
i+=1
a = "{0:.12f}".format(ans)
print(a)
main()
|
[
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 579,422
| 579,423
|
u775681539
|
python
|
p02780
|
N,K=map(int,input().split())
p=list(map(int,input().split()))
S=sum(p[:K])
T=0
for i in range(N-K):
S=S-p[i]+p[i+K]
T=max(T,S)
print((T+K)/2)
|
N,K=map(int,input().split())
p=list(map(int,input().split()))
S=sum(p[:K])
T=S
for i in range(N-K):
S=S-p[i]+p[i+K]
T=max(T,S)
print((T+K)/2)
|
[
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 579,424
| 579,425
|
u507456172
|
python
|
p02780
|
n,k = map(int,input().split())
a = list(map(int,input().split()))
awk = 0
aix = k
for i in range(k):
awk += a[i]
#print(a[i])
#print('--')
a_max = awk
for i in range(k,n):
#print(a[i],i-k)
awk = awk + a[i] - a[i-k]
if a_max < awk:
a_max = awk
aix = i
#print('===')
ans = 0.0
for i in range(aix-k+1,aix+1 ):
#print(a[i],( 1 + a[i] ) / 2.0)
ans += ( 1 + a[i] ) / 2.0
print(ans)
|
n,k = map(int,input().split())
a = list(map(int,input().split()))
awk = 0
aix = k - 1
for i in range(k):
awk += a[i]
a_max = awk
for i in range(k,n):
awk = awk + a[i] - a[i-k]
if a_max < awk:
a_max = awk
aix = i
ans = 0.0
#print('aix={}'.format(aix))
for i in range(aix-k+1,aix+1 ):
#print(a[i])
ans += ( 1 + a[i] ) / 2.0
print(ans)
|
[
"assignment.change"
] | 579,430
| 579,431
|
u094158322
|
python
|
p02780
|
#154d
n, k = map(int, input().split())
p_list = list(map(int, input().split()))
e_list = [(1 + p) / 2 for p in p_list]
max_v = sum(e_list[:k])
ret = max_v
#print(e_list, e_list[:k])
for i in range(n - k):
calc = ret - e_list[i] + e_list[i + k]
max_v = max(ret, calc)
ret = calc
# print(ret, e_list[i], e_list[i + k], calc)
print(max_v)
|
#154d
n, k = map(int, input().split())
p_list = list(map(int, input().split()))
e_list = [(1 + p) / 2 for p in p_list]
max_v = sum(e_list[:k])
ret = max_v
#print(e_list, e_list[:k])
for i in range(n - k):
calc = ret - e_list[i] + e_list[i + k]
max_v = max(max_v, calc)
ret = calc
#print(ret, e_list[i], e_list[i + k], calc)
print(max_v)
|
[
"assignment.value.change",
"identifier.change",
"call.arguments.change"
] | 579,432
| 579,433
|
u123849536
|
python
|
p02780
|
#154d
n, k = map(int, input().split())
p_list = list(map(int, input().split()))
e_list = [(1 + p) / 2 for p in p_list]
max_v = sum(e_list[:k])
ret = max_v
for i in range(n - k):
calc = ret - e_list[i] + e_list[i + k]
max_v = max(ret, calc)
ret = calc
print(max_v)
|
#154d
n, k = map(int, input().split())
p_list = list(map(int, input().split()))
e_list = [(1 + p) / 2 for p in p_list]
max_v = sum(e_list[:k])
ret = max_v
#print(e_list, e_list[:k])
for i in range(n - k):
calc = ret - e_list[i] + e_list[i + k]
max_v = max(max_v, calc)
ret = calc
#print(ret, e_list[i], e_list[i + k], calc)
print(max_v)
|
[
"assignment.value.change",
"identifier.change",
"call.arguments.change"
] | 579,434
| 579,433
|
u123849536
|
python
|
p02780
|
ni = lambda: int(input())
nm = lambda: map(int, input().split())
nl = lambda: list(map(int, input().split()))
n,k = nm()
p = nl()
def exp(num):
ret = (1+num)/2
return ret
mx=0
pp = list(map(exp,p))
pd = [0]*(n+1)
for i in range(1,n):
pd[i] = pd[i-1] + pp[i]
for i in range(n-k+1):
mx = max(pd[i+k]-pd[i],mx)
print(mx)
|
ni = lambda: int(input())
nm = lambda: map(int, input().split())
nl = lambda: list(map(int, input().split()))
n,k = nm()
p = nl()
def exp(num):
ret = (1+num)/2
return ret
mx=0
pp = list(map(exp,p))
pd = [0]*(n+1)
for i in range(1,n+1):
pd[i] = pd[i-1] + pp[i-1]
for i in range(n-k+1):
mx = max(pd[i+k]-pd[i],mx)
print(mx)
|
[
"control_flow.loop.range.bounds.upper.change",
"expression.operation.binary.add",
"assignment.change"
] | 579,445
| 579,446
|
u963915126
|
python
|
p02780
|
n,k=map(int,input().split())
p=list(map(int,input().split()))
f=lambda x:0.5*(x+1)
pp=list(map(f,p))
t=[0]*(n+1)
for i in range(n):
t[i+1]=t[i]+pp[i]
for i in range(n-k+1):
ans=max(ans,t[i+k]-t[i])
print(ans)
|
n,k=map(int,input().split())
p=list(map(int,input().split()))
f=lambda x:0.5*(x+1)
pp=list(map(f,p))
t=[0]*(n+1)
for i in range(n):
t[i+1]=t[i]+pp[i]
ans=0
for i in range(n-k+1):
ans=max(ans,t[i+k]-t[i])
print(ans)
|
[
"assignment.add"
] | 579,451
| 579,452
|
u614162316
|
python
|
p02780
|
import sys
input = sys.stdin.readline
def main():
N, K = map(int, input().split())
p = list(map(int, input().split()))
answer = sum(p[0:K])
r = answer
for i in range(N-K):
answer = answer - p[i] + p[i+K]
print(answer)
r = max(r, answer)
print((r+K)/2)
if __name__ == '__main__':
main()
|
import sys
input = sys.stdin.readline
def main():
N, K = map(int, input().split())
p = list(map(int, input().split()))
answer = sum(p[0:K])
r = answer
for i in range(N-K):
answer = answer - p[i] + p[i+K]
r = max(r, answer)
print((r+K)/2)
if __name__ == '__main__':
main()
|
[
"call.remove"
] | 579,453
| 579,454
|
u061566631
|
python
|
p02780
|
import sys
input = sys.stdin.readline
def main():
N, K = map(int, input().split())
p = list(map(int, input().split()))
answer = sum(p[0:K])
r = answer
for i in range(N-K):
answer = answer - p[i] + p[i+K]
r = max(r, answer)
print((answer+K)/2)
if __name__ == '__main__':
main()
|
import sys
input = sys.stdin.readline
def main():
N, K = map(int, input().split())
p = list(map(int, input().split()))
answer = sum(p[0:K])
r = answer
for i in range(N-K):
answer = answer - p[i] + p[i+K]
r = max(r, answer)
print((r+K)/2)
if __name__ == '__main__':
main()
|
[
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change",
"io.output.change"
] | 579,455
| 579,454
|
u061566631
|
python
|
p02780
|
import itertools
def resolve():
N, K = map(int, input().split())
P = list(map(int, input().split()))
P = [(1 + p) / 2 for p in P]
accumulate_P = [0] + list(itertools.accumulate(P))
ans = 0
for ii in range(N - K):
range_sum_P = accumulate_P[ii + K] - accumulate_P[ii]
ans = max(ans, range_sum_P)
print(ans)
resolve()
|
import itertools
def resolve():
N, K = map(int, input().split())
P = list(map(int, input().split()))
P = [(1 + p) / 2 for p in P]
accumulate_P = [0] + list(itertools.accumulate(P))
ans = 0
for ii in range(N - K + 1):
range_sum_P = accumulate_P[ii + K] - accumulate_P[ii]
ans = max(ans, range_sum_P)
print(ans)
resolve()
|
[
"control_flow.loop.range.bounds.upper.change",
"expression.operation.binary.add"
] | 579,456
| 579,457
|
u586662847
|
python
|
p02780
|
N,K = map(int,input().split())
p = list(map(int,input().split()))
r = 0
s = sum(p[0:K])
for i in range(N-K):
s = s-p[i]+p[i+K]
r = max(r,s)
print((r+K)/2)
|
N,K = map(int,input().split())
p = list(map(int,input().split()))
s = sum(p[0:K])
r = s
for i in range(N-K):
s = s-p[i]+p[i+K]
r = max(r,s)
print((r+K)/2)
|
[
"assignment.remove",
"assignment.add"
] | 579,461
| 579,462
|
u662615460
|
python
|
p02780
|
n,k= list(map(int, input().split()))
j = list(map(int, input().split()))
s=0
sumlist=[0]*n
anslist=[0]*(n-k+1)
for i in range(n):
s+=j[i]
sumlist[i]=s
for i in range(len(anslist)):
z=sumlist[i+k]-sumlist[i]
anslist[i]=z
ans=max(anslist)
ans+=k
ans=ans/2
print(ans)
|
n,k= list(map(int, input().split()))
j = list(map(int, input().split()))
s=0
sumlist=[0]*(n+1)
anslist=[0]*(n-k+1)
for i in range(n):
s+=j[i]
sumlist[i+1]=s
for i in range(len(anslist)):
z=sumlist[i+k]-sumlist[i]
anslist[i]=z
ans=max(anslist)
ans+=k
ans=ans/2
print(ans)
|
[
"assignment.change"
] | 579,465
| 579,466
|
u185405877
|
python
|
p02780
|
from __future__ import print_function
import sys
sys.setrecursionlimit(500000)
import re
import array
import copy
import functools
import operator
import math
import string
from fractions import Fraction
import collections
import itertools
import bisect
import random
import time
import heapq
from heapq import heappush
from heapq import heappop
from heapq import heappushpop
from heapq import heapify
from heapq import heapreplace
from queue import PriorityQueue as pq
from queue import Queue
from itertools import accumulate
from collections import deque
from collections import Counter
from operator import mul
from functools import reduce
input = sys.stdin.readline
def eprint(*args, **kwargs):
print(*args, file=sys.stderr, **kwargs)
return
# from fractions import gcd
# from math import gcd
# def lcm(n, m):
# return int(n * m / gcd(n, m))
# def coprimize(p, q):
# common = gcd(p, q)
# return (p // common, q // common)
# def find_gcd(list_l):
# x = reduce(gcd, list_l)
# return x
def combinations_count(n, r):
r = min(r, n - r)
numer = reduce(mul, range(n, n - r, -1), 1)
denom = reduce(mul, range(1, r + 1), 1)
return numer // denom
def main():
n,k = map(int,input().strip().split()) # 1 <= k <= n <= 2*10^5
p = list(map(lambda n: Fraction( (int(n)+1),2 ), input().strip().split())) # p[i] <= 10^3
xsum=sum(p[0:k]) # 0 <= i < k
ans=0
for i in range(k,n): # k <= i < n
xsum = xsum + p[i] - p[i-k]
ans = max(ans,xsum)
print(float(ans))
if __name__ == '__main__':
main()
|
from __future__ import print_function
import sys
sys.setrecursionlimit(500000)
import re
import array
import copy
import functools
import operator
import math
import string
from fractions import Fraction
import collections
import itertools
import bisect
import random
import time
import heapq
from heapq import heappush
from heapq import heappop
from heapq import heappushpop
from heapq import heapify
from heapq import heapreplace
from queue import PriorityQueue as pq
from queue import Queue
from itertools import accumulate
from collections import deque
from collections import Counter
from operator import mul
from functools import reduce
input = sys.stdin.readline
def eprint(*args, **kwargs):
print(*args, file=sys.stderr, **kwargs)
return
# from fractions import gcd
# from math import gcd
# def lcm(n, m):
# return int(n * m / gcd(n, m))
# def coprimize(p, q):
# common = gcd(p, q)
# return (p // common, q // common)
# def find_gcd(list_l):
# x = reduce(gcd, list_l)
# return x
def combinations_count(n, r):
r = min(r, n - r)
numer = reduce(mul, range(n, n - r, -1), 1)
denom = reduce(mul, range(1, r + 1), 1)
return numer // denom
def main():
n,k = map(int,input().strip().split()) # 1 <= k <= n <= 2*10^5
p = list(map(lambda n: Fraction( int(n)+1,2 ), input().strip().split())) # p[i] <= 10^3
xsum=sum(p[0:k]) # 0 <= i < k
ans=xsum
for i in range(k,n): # k <= i < n
xsum = xsum + p[i] - p[i-k]
ans = max(ans,xsum)
print(float(ans))
if __name__ == '__main__':
main()
|
[
"call.arguments.change",
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 579,482
| 579,483
|
u185249212
|
python
|
p02780
|
N, K = [int(_) for _ in input().split()]
P = [int(_) for _ in input().split()]
E = [(p + 1)/2 for p in P]
sumE = sum(E[0:K])
ans = sumE
for i in range(1, N-K):
sumE = sumE - E[i-1] + E[i+K]
ans = max(ans, sumE)
print(ans)
|
N, K = [int(_) for _ in input().split()]
P = [int(_) for _ in input().split()]
E = [(p + 1)/2 for p in P]
sumE = sum(E[0:K])
ans = sumE
for i in range(1, N-K+1):
sumE = sumE - E[i-1] + E[i+K-1]
ans = max(ans, sumE)
print(ans)
|
[
"control_flow.loop.range.bounds.upper.change",
"expression.operation.binary.add",
"assignment.change"
] | 579,502
| 579,503
|
u504562455
|
python
|
p02780
|
from itertools import accumulate
import numpy as np
n, k = map(int, input().split())
p = np.array(list(map(int, input().split())), dtype=np.int64)
p = (1 + p) / 2
p = [0] + list(accumulate(p))
ans = 0
for i in range(k):
ans = max(ans, p[i + k] - p[i])
print(ans)
|
from itertools import accumulate
import numpy as np
n, k = map(int, input().split())
p = np.array(list(map(int, input().split())), dtype=np.int64)
p = (1 + p) / 2
p = [0] + list(accumulate(p))
ans = 0
for i in range(n - k + 1):
ans = max(ans, p[i + k] - p[i])
print(ans)
|
[
"control_flow.loop.range.bounds.upper.change",
"expression.operation.binary.add"
] | 579,511
| 579,512
|
u377989038
|
python
|
p02780
|
N, K = map(int, input().split())
P = list(map(int, input().split()))
acc = [0] * (N+1)
for i in range(0, N):
acc[i+1] = acc[i] + P[i]
print(acc)
ans = 0
for i in range(0, N-K+1):
tmp = acc[i+K] - acc[i]
if tmp > ans:
ans = tmp
print((ans+K)/2)
|
N, K = map(int, input().split())
P = list(map(int, input().split()))
acc = [0] * (N+1)
for i in range(0, N):
acc[i+1] = acc[i] + P[i]
ans = 0
for i in range(0, N-K+1):
tmp = acc[i+K] - acc[i]
if tmp > ans:
ans = tmp
print((ans+K)/2)
|
[
"call.remove"
] | 579,515
| 579,516
|
u855710796
|
python
|
p02780
|
class BIT:
def __init__(self, n):
self.node = [ 0 for _ in range(n+1) ]
def add(self, idx, w):
i = idx
while i < len(self.node) - 1:
self.node[i] += w
i |= (i + 1)
def sum_(self, idx):
ret, i = 0, idx-1
while i >= 0:
ret += self.node[i]
i = (i & (i + 1)) - 1
return ret
def sum(self, l, r):
return self.sum_(r) - self.sum_(l)
n, k = map(int, input().split())
tree = BIT(n)
p = [ int(x) for x in input().split() ]
for i in range(n):
tree.add(i, (1+p[i])/2)
ans = 0
for i in range(n-k+1):
ans = tree.sum(i, i+k)
print(ans)
|
class BIT:
def __init__(self, n):
self.node = [ 0 for _ in range(n+1) ]
def add(self, idx, w):
i = idx
while i < len(self.node) - 1:
self.node[i] += w
i |= (i + 1)
def sum_(self, idx):
ret, i = 0, idx-1
while i >= 0:
ret += self.node[i]
i = (i & (i + 1)) - 1
return ret
def sum(self, l, r):
return self.sum_(r) - self.sum_(l)
n, k = map(int, input().split())
tree = BIT(n)
p = [ int(x) for x in input().split() ]
for i in range(n):
tree.add(i, (1+p[i])/2)
ans = 0
for i in range(n-k+1):
ans = max(ans, tree.sum(i, i+k))
print(ans)
|
[
"call.add",
"call.arguments.change"
] | 579,524
| 579,525
|
u813098295
|
python
|
p02780
|
n,k = map(int, input().split())
p=list(map(float, input().split()))
for i in range(len(p)):
p[i] = (1+p[i]) / 2
max = 0
for i in range(k):
max += p[i]
print(max)
tmp = max
for i in range(n-k):
tmp = tmp - p[i] + p[i+k]
if max < tmp: max = tmp
print(max)
|
n,k = map(int, input().split())
p=list(map(float, input().split()))
for i in range(len(p)):
p[i] = (1+p[i]) / 2
max = 0
for i in range(k):
max += p[i]
tmp = max
for i in range(n-k):
tmp = tmp - p[i] + p[i+k]
if max < tmp: max = tmp
print(max)
|
[
"call.remove"
] | 579,526
| 579,527
|
u908505367
|
python
|
p02780
|
n, k = map(int, input().split())
p_list = list(map(int, input().split()))
def get_val(a):
return 1+a/2
current = 0
for i in range(k):
current += get_val(p_list[i])
max = current
for i in range(k, n):
current -= get_val(p_list[i-k])
current += get_val(p_list[i])
if max < current:
max = current
print(max)
|
n, k = map(int, input().split())
p_list = list(map(int, input().split()))
def get_val(a):
return (1+a)/2
current = 0
for i in range(k):
current += get_val(p_list[i])
max = current
for i in range(k, n):
current -= get_val(p_list[i-k])
current += get_val(p_list[i])
if max < current:
max = current
print(max)
|
[
"function.return_value.change"
] | 579,528
| 579,529
|
u396858476
|
python
|
p02780
|
M,N = list(map(int,input().split()))
s = list(map(int,input().split()))
count = 0
t = [0 for i in range(M+1)]
for i in range(M):
t[i+1] = t[i] + (1+s[i])/2
for i in range(N,M-N+1):
count = max(count,t[i]-t[i-N])
print(count)
|
M,N = list(map(int,input().split()))
s = list(map(int,input().split()))
count = 0
kiroku = 0
t = [0 for i in range(M+1)]
for i in range(M):
t[i+1] = t[i] + (1+s[i])/2
for i in range(N,M+1):
count = max(count,t[i]-t[i-N])
print(count)
|
[
"expression.operation.binary.remove"
] | 579,542
| 579,543
|
u592035627
|
python
|
p02780
|
import itertools
n, k = map(int, input().split())
p = list(map(int, input().split()))
acc = [0] + list(itertools.accumulate([(x+1)/2 for x in p])) # 累積和を計算
ans = max(acc[i]-acc[i-k] for i in range(k, n+1)) # k番目からn番目まで計算
|
import itertools
n, k = map(int, input().split())
p = list(map(int, input().split()))
acc = [0] + list(itertools.accumulate([(x+1)/2 for x in p])) # 累積和を計算
ans = max(acc[i]-acc[i-k] for i in range(k, n+1)) # k番目からn番目まで計算
print(ans)
|
[
"call.add"
] | 579,548
| 579,549
|
u802581810
|
python
|
p02780
|
n,k=map(int,input().split())
p=list(map(int,input().split()))
sum1=0
a=[]
for j in range(k):
sum1=sum1+((1+p[j])/2)
a.append(sum1)
for i in range(1,n-k+1):
sum1=sum1-((1+p[i-1])/2)+((1+p[i+k-1])/2)
a.append(sum1)
ans=max(a)
print(ans)
print(a)
|
n,k=map(int,input().split())
p=list(map(int,input().split()))
sum1=0
a=[]
for j in range(k):
sum1=sum1+((1+p[j])/2)
a.append(sum1)
for i in range(1,n-k+1):
sum1=sum1-((1+p[i-1])/2)+((1+p[i+k-1])/2)
a.append(sum1)
ans=max(a)
print(ans)
|
[
"call.remove"
] | 579,559
| 579,560
|
u224119985
|
python
|
p02780
|
N,K = map(int, input().split())
A = [(1+int(x))/2 for x in input().split()]
wa = []
w = 0
for i in range(0,K):
w = w+A[i]
wa.append(w)
for j in range(N-k):
w = w + wa[j+K] - wa[j]
wa.append(w)
print(max(wa))
|
N,K = map(int, input().split())
A = [(1+int(x))/2 for x in input().split()]
wa = []
w = 0
for i in range(0,K):
w = w+A[i]
wa.append(w)
for j in range(N-K):
w = w + A[j+K] - A[j]
wa.append(w)
print(max(wa))
|
[
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change",
"control_flow.loop.range.bounds.upper.change",
"assignment.value.change"
] | 579,569
| 579,570
|
u118760114
|
python
|
p02780
|
N,K=map(int,input().split())
p = list(map(int,input().split()))
m = [(maximum + 1) / 2 for maximum in p]#平均値のリスト m を作って、幅 K の Sliding Window
print(m)
t = sum(m[0:K])#K番目までの合計
result = t#初期結果
for i in range(N - K):
t -= m[i]#末尾引いて
t += m[i + K]#新しいのタス
if t > result:
result = t
print(result)
|
N, K = map(int, input().split())
p = list(map(int, input().split()))
m = [(e + 1) / 2 for e in p]
t = sum(m[0:K])
result = t
for i in range(N - K):
t -= m[i]
t += m[i + K]
if t > result:
result = t
print(result)
|
[
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change",
"call.remove"
] | 579,588
| 579,589
|
u753386263
|
python
|
p02780
|
N, K = map(int, input().split())
p_list = list(map(int, input().split()))
c_s_list = [] #Cumulative sum_list
c_sum = 0 #Cumulative sum
for dice in p_list:
average = (dice + 1) / 2 #ダイスの期待値
c_sum += average
c_s_list.append(c_sum)
ans = 0
for i in range(N-K):
tmp = c_s_list[i+K] - c_s_list[i]
if tmp >= ans:
ans = tmp
print(ans)
|
N, K = map(int, input().split())
p_list = list(map(int, input().split()))
c_s_list = [0] #Cumulative sum_list
c_sum = 0 #Cumulative sum
for dice in p_list:
average = (dice + 1) / 2 #ダイスの期待値
c_sum += average
c_s_list.append(c_sum)
ans = 0
for i in range(N-K+1):
tmp = c_s_list[i+K] - c_s_list[i]
if tmp >= ans:
ans = tmp
print(ans)
|
[
"control_flow.loop.range.bounds.upper.change",
"expression.operation.binary.add"
] | 579,590
| 579,591
|
u212328220
|
python
|
p02780
|
N, K = map(int, input().split())
p_list = list(map(int, input().split()))
c_s_list = [] #Cumulative sum_list
c_sum = 0 #Cumulative sum
for dice in p_list:
average = (dice + 1) / 2 #ダイスの期待値
c_sum += average
c_s_list.append(c_sum)
ans = 0
for i in range(N-K):
tmp = c_s_list[i+K] - c_s_list[i]
if tmp > ans:
ans = tmp
print(ans)
|
N, K = map(int, input().split())
p_list = list(map(int, input().split()))
c_s_list = [0] #Cumulative sum_list
c_sum = 0 #Cumulative sum
for dice in p_list:
average = (dice + 1) / 2 #ダイスの期待値
c_sum += average
c_s_list.append(c_sum)
ans = 0
for i in range(N-K+1):
tmp = c_s_list[i+K] - c_s_list[i]
if tmp >= ans:
ans = tmp
print(ans)
|
[
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 579,592
| 579,591
|
u212328220
|
python
|
p02780
|
n, k = map(int, input().split())
p = list(map(int, input().split()))
l = [0] * (n + 1)
ans = []
for i in range(n):
l[i + 1] = l[i] + (p[i] + 1) / 2
print(l)
for i in range(n - k + 1):
ans.append(l[i + k] - l[i])
print(max(ans))
|
n, k = map(int, input().split())
p = list(map(int, input().split()))
l = [0] * (n + 1)
ans = []
for i in range(n):
l[i + 1] = l[i] + (p[i] + 1) / 2
for i in range(n - k + 1):
ans.append(l[i + k] - l[i])
print(max(ans))
|
[
"call.remove"
] | 579,599
| 579,600
|
u923270446
|
python
|
p02780
|
n,k = map(int,input().split())
a = list(map(int,input().split()))
e = [0]*n
b = [0]*n-(k-1)
for i in range(n):
e[i] = (1+a[i])/2
b[0] = sum(e[0:k])
for i in range(1, len(b)):
b[i] = e[i] + b[i-1] - e[i-1]
print(max(b))
|
n,k = map(int,input().split())
a = list(map(int,input().split()))
e = [0]*n
b = [0]*(n-(k-1))
for i in range(n):
e[i] = (1+a[i])/2
b[0] = sum(e[0:k])
for i in range(1, len(b)):
b[i] = e[i+k-1] + b[i-1] - e[i-1]
print(max(b))
|
[
"assignment.change"
] | 579,602
| 579,603
|
u626881915
|
python
|
p02780
|
n, k = map(int, input().split())
p = list(map(int, input().split()))
p_mx=0
for i in range(k):
p_sm += p[i]
p_mx=p_sm
for i in range(n-k):
p_sm= p_sm + p[k+i]-p[i]
if p_sm >p_mx:
p_mx = p_sm
print((p_mx+k)/2)
|
n, k = map(int, input().split())
p = list(map(int, input().split()))
p_sm=0
for i in range(k):
p_sm += p[i]
p_mx=p_sm
for i in range(n-k):
p_sm= p_sm + p[k+i]-p[i]
if p_sm >p_mx:
p_mx = p_sm
print((p_mx+k)/2)
|
[
"assignment.variable.change",
"identifier.change"
] | 579,612
| 579,613
|
u693173434
|
python
|
p02780
|
N,K = map(int, input().split())
P = list(map(int,input().split()))
Px =[]
for i in range(N):
Px.append((1+P[i])/2)
temp_num = sum(Px[0:K])
temp_max = sum(Px[0:K])
for j in range(N-K+1):
temp_num = temp_num-Px[j]+Px[j+K-1]
if temp_max <temp_num:
temp_max=temp_num
print(temp_max)
|
N,K = map(int, input().split())
P = list(map(int,input().split()))
Px =[]
for i in range(N):
Px.append((1+P[i])/2)
temp_num = sum(Px[0:K])
temp_max = sum(Px[0:K])
#print(Px)
for j in range(N-K):
#print(temp_num)
temp_num = temp_num-Px[j]+Px[j+K]
if temp_max <temp_num:
temp_max=temp_num
print(temp_max)
|
[
"expression.operation.binary.remove"
] | 579,627
| 579,628
|
u863964720
|
python
|
p02780
|
#!/usr/bin python3
# -*- coding: utf-8 -*-
import sys
input = sys.stdin.readline
def main():
N, K = map(int, input().split())
P = list(map(int, input().split()))
Et = [0]*(N+1)
for i in range(N):
Et[i] = Et[i-1] + (1+P[i])/2
ret = 0
for i in range(N-K+1):
ret = max(ret, Et[i+K]-Et[i])
print(ret)
if __name__ == '__main__':
main()
|
#!/usr/bin python3
# -*- coding: utf-8 -*-
import sys
input = sys.stdin.readline
def main():
N, K = map(int, input().split())
P = list(map(int, input().split()))
Et = [0]*(N+1)
for i in range(N):
Et[i+1] = Et[i] + (1+P[i])/2
ret = 0
for i in range(N-K+1):
ret = max(ret, Et[i+K]-Et[i])
print(ret)
if __name__ == '__main__':
main()
|
[
"expression.operation.binary.remove"
] | 579,639
| 579,640
|
u113971909
|
python
|
p02780
|
def main():
n,k=map(int,input().split())
p=list(map(int,input().split()))
kitai=[]
ans=0
for i in range(n):
buf=sum(range(1,p[i]+1))/p[i]
kitai.append(buf)
if i<=k-1:
ans+=buf
x=ans
for i in range(k,n):
x-=kitai[i-1]
x+=kitai[i]
if ans<=x:
ans=x
print(ans)
if __name__=='__main__':
main()
|
def main():
n,k=map(int,input().split())
p=list(map(int,input().split()))
kitai=[]
ans=0
for i in range(n):
buf=sum(range(1,p[i]+1))/p[i]
kitai.append(buf)
if i<=k-1:
ans+=buf
x=ans
for i in range(k,n):
x-=kitai[i-k]
x+=kitai[i]
if ans<=x:
ans=x
print(ans)
if __name__=='__main__':
main()
|
[
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 579,643
| 579,644
|
u993310962
|
python
|
p02780
|
import numpy as np
N,K=map(int,input().split())
P=list(map(int,input().split()))
Q=[]
def ex(A):
return (1+A)/2.0
for i in range(N):
Q.append(ex(P[i]))
Q=np.array(Q)
R=Q.cumsum()
ans=0.0
for i in range(K,N+1):
S=R[i]-R[i-K]
if ans<S:
ans=S
print(ans)
|
import numpy as np
N,K=map(int,input().split())
P=list(map(int,input().split()))
Q=[0]
def ex(A):
return (1+A)/2.0
for i in range(N):
Q.append(ex(P[i]))
Q=np.array(Q)
R=Q.cumsum()
ans=0
for i in range(K,N+1):
S=R[i]-R[i-K]
if ans<S:
ans=S
print(ans)
|
[
"assignment.value.change"
] | 579,656
| 579,657
|
u506858457
|
python
|
p02780
|
import numpy as np
N,K=map(int,input().split())
P=list(map(int,input().split()))
Q=[]
def ex(A):
return (1+A)/2.0
for i in range(N):
Q.append(ex(P[i]))
Q=np.array(Q)
R=Q.cumsum()
ans=0
for i in range(K-1,N):
S=R[i]-R[i-K]
if ans<S:
ans=S
print(ans)
|
import numpy as np
N,K=map(int,input().split())
P=list(map(int,input().split()))
Q=[0]
def ex(A):
return (1+A)/2.0
for i in range(N):
Q.append(ex(P[i]))
Q=np.array(Q)
R=Q.cumsum()
ans=0
for i in range(K,N+1):
S=R[i]-R[i-K]
if ans<S:
ans=S
print(ans)
|
[
"expression.operation.binary.remove"
] | 579,658
| 579,657
|
u506858457
|
python
|
p02780
|
import numpy as np
N,K=map(int,input().split())
P=list(map(int,input().split()))
Q=[]
def ex(A):
return (1+A)/2.0
for i in range(N):
Q.append(ex(P[i]))
Q=np.array(Q)
R=Q.cumsum()
ans=0
for i in range(K,N):
S=R[i]-R[i-K]
if ans<S:
ans=S
print(ans)
|
import numpy as np
N,K=map(int,input().split())
P=list(map(int,input().split()))
Q=[0]
def ex(A):
return (1+A)/2.0
for i in range(N):
Q.append(ex(P[i]))
Q=np.array(Q)
R=Q.cumsum()
ans=0
for i in range(K,N+1):
S=R[i]-R[i-K]
if ans<S:
ans=S
print(ans)
|
[
"control_flow.loop.range.bounds.upper.change",
"expression.operation.binary.add"
] | 579,659
| 579,657
|
u506858457
|
python
|
p02780
|
import math
n, k = map(int, input().split(" "))
pL = list(map(int, input().split(" ")))
mx = 0
cs = 0
for i in range(k):
cs += pL[i]
mx = cs
for i in range(1, len(pL) - k + 1):
cs = cs - pL[i - 1] + pL[i + k - 1]
print(cs)
mx = max(mx, cs)
print((mx + k) / 2)
|
import math
n, k = map(int, input().split(" "))
pL = list(map(int, input().split(" ")))
mx = 0
cs = 0
for i in range(k):
cs += pL[i]
mx = cs
for i in range(1, len(pL) - k + 1):
cs = cs - pL[i - 1] + pL[i + k - 1]
mx = max(mx, cs)
print((mx + k) / 2)
|
[
"call.remove"
] | 579,663
| 579,664
|
u552176911
|
python
|
p02780
|
import sys
input = lambda: sys.stdin.readline().rstrip()
n, k = map(int, input().split())
p = list(map(int, input().split()))
ans = 0
s_list = [0]*(n+1)
s_list[1] = p[0]
for i in range(1, n+1):
s_list[i] = p[i-1] + s_list[i-1]
for i in range(1, n-k+1):
e = (s_list[i+k] - s_list[i] + k)/2
if ans < e:
ans = e
print(ans)
|
import sys
input = lambda: sys.stdin.readline().rstrip()
n, k = map(int, input().split())
p = list(map(int, input().split()))
ans = 0
s_list = [0]*(n+1)
s_list[1] = p[0]
for i in range(1, n+1):
s_list[i] = p[i-1] + s_list[i-1]
for i in range(n-k+1):
e = (s_list[i+k] - s_list[i] + k)/2
if ans < e:
ans = e
print(ans)
|
[
"call.arguments.change"
] | 579,672
| 579,673
|
u453055089
|
python
|
p02780
|
import numpy as np
N, K = map(int, input().split())
p = np.array(list(map(int, input().split())))
ans = 0
tmp = np.sum((p[0:K]+1)/2)
for n in range(1, N-K+1):
last = (p[n-1]+1)/2
next = (p[n+K-1]+1)/2
tmp = tmp - last + next
if ans < tmp:
ans = tmp
print(ans)
|
import numpy as np
N, K = map(int, input().split())
p = np.array(list(map(int, input().split())))
ans = tmp = np.sum((p[0:K]+1)/2)
for n in range(1, N-K+1):
last = (p[n-1]+1)/2
next = (p[n+K-1]+1)/2
tmp = tmp - last + next
if ans < tmp:
ans = tmp
print(ans)
|
[] | 579,674
| 579,675
|
u427819770
|
python
|
p02780
|
N, K = map(int, input().split())
P = list(map(int, input().split()))
E = []
for p in P:
e = ((p * p + p) / 2) * (1 / p)
E.append(e)
ans = 0
memo = sum(E[:K])
for i in range(0, N - K):
memo = memo - E[i] + E[i + K]
ans = max(ans, memo)
print(ans)
|
N, K = map(int, input().split())
P = list(map(int, input().split()))
E = []
for p in P:
e = ((p * p + p) / 2) * (1 / p)
E.append(e)
memo = sum(E[:K])
ans = memo
for i in range(0, N - K):
memo = memo - E[i] + E[i + K]
ans = max(ans, memo)
print(ans)
|
[
"assignment.remove",
"assignment.add"
] | 579,684
| 579,685
|
u298633786
|
python
|
p02780
|
n, k = map(int, input().split())
p = list(map(int, input().split()))
meanList = []
for a in p:
meanList.append((a + 1) / 2)
sums = [0]
for a in meanList:
sums.append(sums[-1] + a)
ans = 0
for i in range(n-k):
ans = max(ans, sums[k+i] - sums[i])
print(ans)
|
n, k = map(int, input().split())
p = list(map(int, input().split()))
meanList = []
for a in p:
meanList.append((a + 1) / 2)
sums = [0]
for a in meanList:
sums.append(sums[-1] + a)
ans = 0
for i in range(n - k + 1):
ans = max(ans, sums[k+i] - sums[i])
print(ans)
|
[
"control_flow.loop.range.bounds.upper.change",
"expression.operation.binary.add"
] | 579,688
| 579,689
|
u845620905
|
python
|
p02780
|
N, K = map(int, input().split())
*p, = map(int, input().split())
Ep = [(x + 1) / 2 for x in p]
sums = [0 for _ in range(N - K + 1)]
sums[0] = sum(Ep[:K])
for i in range(N-K):
sums[i+1] = sums[i]+Ep[i+K]-Ep[i]
print(sums)
|
N, K = map(int, input().split())
*p, = map(int, input().split())
Ep = [(x + 1) / 2 for x in p]
sums = [0 for _ in range(N - K + 1)]
sums[0] = sum(Ep[:K])
for i in range(N-K):
sums[i+1] = sums[i]+Ep[i+K]-Ep[i]
print(max(sums))
|
[
"call.arguments.add",
"call.arguments.change"
] | 579,697
| 579,698
|
u073139376
|
python
|
p02780
|
N,K=map(int,input().split())
p=list(map(int,input().split()))
def P(x):
return (x+1)/2
a=0
y=0
for i in range(N-K):
y+=P(p[i])#区間内の期待値の和
if i>=K:
y-=P(p[i-K])
if a<y:
a=y
print(a)
|
N,K=map(int,input().split())
p=list(map(int,input().split()))
def P(x):
return (x+1)/2
a=0
y=0
for i in range(N):
y+=P(p[i])#区間内の期待値の和
if i>=K:
y-=P(p[i-K])
if a<y:
a=y
print(a)
|
[
"expression.operation.binary.remove"
] | 579,699
| 579,700
|
u349444371
|
python
|
p02780
|
N,K=map(int,input().split())
p=list(map(int,input().split()))
def P(x):
return (x+1)/2
a=0
y=0
for i in range(N-K+1):
y+=P(p[i])
if i>=K:
y-=P(p[i-K])
if a<y:
a=y
print(a)
|
N,K=map(int,input().split())
p=list(map(int,input().split()))
def P(x):
return (x+1)/2
a=0
y=0
for i in range(N):
y+=P(p[i])#区間内の期待値の和
if i>=K:
y-=P(p[i-K])
if a<y:
a=y
print(a)
|
[
"expression.operation.binary.remove"
] | 579,701
| 579,700
|
u349444371
|
python
|
p02780
|
# ABC154 -virtual
# A
if False:
S,T=input().split()
A,B=map(int,input().split())
U=input()
if U==S:
A-=1
else:
B-=1
print(A,B)
# B
if False: print('x'*len(input()))
# C
if False:
N=int(input())
A=[int(i) for i in input().split()]
print('YES' if len(A)==len(set(A)) else 'NO')
# D
if True:
N,K=map(int,input().split())
P=[int(i) for i in input().split()]
E=[(p+1)/2 for p in P]
# print(E)
ans=0
tmp=sum(E[0:K])
l,r=1,K
while r<len(E):
# print(l,r)
tmp=tmp-E[l-1]+E[r]
ans=max(ans,tmp)
# print(ans)
l+=1
r+=1
print(ans)
# E
# F
|
# ABC154 -virtual
# A
if False:
S,T=input().split()
A,B=map(int,input().split())
U=input()
if U==S:
A-=1
else:
B-=1
print(A,B)
# B
if False: print('x'*len(input()))
# C
if False:
N=int(input())
A=[int(i) for i in input().split()]
print('YES' if len(A)==len(set(A)) else 'NO')
# D
if True:
N,K=map(int,input().split())
P=[int(i) for i in input().split()]
E=[(p+1)/2 for p in P]
# print(E)
ans=tmp=sum(E[0:K])
l,r=1,K
while r<len(E):
# print(l,r)
tmp=tmp-E[l-1]+E[r]
ans=max(ans,tmp)
# print(ans)
l+=1
r+=1
print(ans)
# E
# F
|
[] | 579,702
| 579,703
|
u202570162
|
python
|
p02780
|
from itertools import accumulate
N,K = map(int,input().split())
P = [(int(i) + 1) / 2 for i in input().split()]
ans = []
hope = [0] + list(accumulate(P))
print(hope)
for j in range(N-K+1):
ans.append(hope[j+K]-hope[j])
print(max(ans))
|
from itertools import accumulate
N,K = map(int,input().split())
P = [(int(i) + 1) / 2 for i in input().split()]
ans = []
hope = [0] + list(accumulate(P))
for j in range(N-K+1):
ans.append(hope[j+K]-hope[j])
print(max(ans))
|
[
"call.remove"
] | 579,704
| 579,705
|
u442877951
|
python
|
p02780
|
N,K = map(int,input().split())
p = list(map(int,input().split()))
ans = 0
for i in range(N):
p[i] = (p[i]+1)/2
total = sum(p[:K])
for j in range(N-K):
total = total+p[K+j]-p[j]
ans = max(ans,total)
print(ans)
|
N,K = map(int,input().split())
p = list(map(int,input().split()))
for i in range(N):
p[i] = (p[i]+1)/2
total = sum(p[:K])
ans = total
for j in range(N-K):
total = total+p[K+j]-p[j]
ans = max(ans,total)
print(ans)
|
[
"assignment.remove",
"assignment.add"
] | 579,706
| 579,707
|
u442877951
|
python
|
p02780
|
N,K = map(int,input().split())
P = list(map(int,input().split()))
for i in range(N):
P[i] = (P[i]+1)/2
R = sum(Q[:K])
ans = R
for j in range(N-K):
R = R - P[j] + P[j+K]
ans = max(ans,R)
print(ans)
|
N,K = map(int,input().split())
P = list(map(int,input().split()))
for i in range(N):
P[i] = (P[i]+1)/2
R = sum(P[:K])
ans = R
for j in range(N-K):
R = R - P[j] + P[j+K]
ans = max(ans,R)
print(ans)
|
[
"assignment.value.change",
"identifier.change",
"call.arguments.change"
] | 579,708
| 579,709
|
u442877951
|
python
|
p02780
|
# -*- coding: utf-8 -*-
"""
Created on Sun Apr 12 04:56:52 2020
@author: Kanaru Sato
"""
n,k = list(map(int, input().split()))
p = list(map(int, input().split()))
sum = 0
sumlist = [0]
for i in range(n):
sum += p[i]
sumlist.append(sum)
Max = -100000
for i in range(n-k):
e = sumlist[i+k]-sumlist[i]
if Max < e:
Max = e
print((Max+k)/2)
|
# -*- coding: utf-8 -*-
"""
Created on Sun Apr 12 04:56:52 2020
@author: Kanaru Sato
"""
n,k = list(map(int, input().split()))
p = list(map(int, input().split()))
sum = 0
sumlist = [0]
for i in range(n):
sum += p[i]
sumlist.append(sum)
Max = -100000
for i in range(n-k+1):
e = sumlist[i+k]-sumlist[i]
if Max < e:
Max = e
print((Max+k)/2)
|
[
"control_flow.loop.range.bounds.upper.change",
"expression.operation.binary.add"
] | 579,710
| 579,711
|
u674052742
|
python
|
p02780
|
# -*- coding: utf-8 -*-
"""
Created on Sun Apr 12 04:56:52 2020
@author: Kanaru Sato
"""
n,k = list(map(int, input().split()))
p = list(map(int, input().split()))
sum = 0
sumlist = [0]
for i in range(n):
sum += p[i]
sumlist.append(sum)
print(sumlist)
Max = -100000
for i in range(n-k):
e = sumlist[i+k]-sumlist[i]
if Max < e:
Max = e
print((Max+k)/2)
|
# -*- coding: utf-8 -*-
"""
Created on Sun Apr 12 04:56:52 2020
@author: Kanaru Sato
"""
n,k = list(map(int, input().split()))
p = list(map(int, input().split()))
sum = 0
sumlist = [0]
for i in range(n):
sum += p[i]
sumlist.append(sum)
Max = -100000
for i in range(n-k+1):
e = sumlist[i+k]-sumlist[i]
if Max < e:
Max = e
print((Max+k)/2)
|
[
"call.remove"
] | 579,712
| 579,711
|
u674052742
|
python
|
p02780
|
# -*- coding: utf-8 -*-
"""
Created on Sun Apr 12 04:56:52 2020
@author: Kanaru Sato
"""
n,k = list(map(int, input().split()))
p = list(map(int, input().split()))
sum = 0
sumlist = []
for i in range(n):
sum += a[i]
sumlist.append(sum)
Max = -100000
for i in range(n-k+1):
e = sumlist[i+k-1]-sumlist[i]
if Max < e:
Max = e
print((Max+k)/2)
|
# -*- coding: utf-8 -*-
"""
Created on Sun Apr 12 04:56:52 2020
@author: Kanaru Sato
"""
n,k = list(map(int, input().split()))
p = list(map(int, input().split()))
sum = 0
sumlist = [0]
for i in range(n):
sum += p[i]
sumlist.append(sum)
Max = -100000
for i in range(n-k+1):
e = sumlist[i+k]-sumlist[i]
if Max < e:
Max = e
print((Max+k)/2)
|
[
"identifier.change",
"expression.operation.binary.remove"
] | 579,713
| 579,711
|
u674052742
|
python
|
p02780
|
import sys
sys.setrecursionlimit(700000)
def s_in():
return input()
def n_in():
return int(input())
def l_in():
return list(map(int, input().split()))
class Interval():
def __init__(self, li):
self.li = li
self.n = len(li)
self.sum_li = [li[0]]
for i in range(1, self.n):
self.sum_li.append(self.sum_li[i-1] + li[i])
def sum(self, a, b=None):
if b is None:
return self.sum(0, a)
res = self.sum_li[min(self.n-1, b-1)]
if a > 0:
res -= self.sum_li[a-1]
return res
n,k = l_in()
P = list(map(lambda p: (1+p)/2, l_in()))
print(P)
res = sum(P[:k])
current = res
for i in range(k, n):
current -= P[i-k]
current += P[i]
res = max(res, current)
print(res)
|
import sys
sys.setrecursionlimit(700000)
def s_in():
return input()
def n_in():
return int(input())
def l_in():
return list(map(int, input().split()))
class Interval():
def __init__(self, li):
self.li = li
self.n = len(li)
self.sum_li = [li[0]]
for i in range(1, self.n):
self.sum_li.append(self.sum_li[i-1] + li[i])
def sum(self, a, b=None):
if b is None:
return self.sum(0, a)
res = self.sum_li[min(self.n-1, b-1)]
if a > 0:
res -= self.sum_li[a-1]
return res
n,k = l_in()
P = list(map(lambda p: (1+p)/2, l_in()))
res = sum(P[:k])
current = res
for i in range(k, n):
current -= P[i-k]
current += P[i]
res = max(res, current)
print(res)
|
[
"call.remove"
] | 579,718
| 579,719
|
u291278680
|
python
|
p02780
|
input_line=input().split(" ")
N,K=int(input_line[0]),int(input_line[1])
P=input().split(" ")
cumsum=[0]
tol=0
for i in range(N):
P[i]=(int(P[i])+1)/2
tol=tol+P[i]
cumsum.append(tol)
k_sum=[]
for i in range(K):
k_sum.append(cumsum[i+K]-cumsum[i])
ans=max(k_sum)
print(ans)
|
input_line=input().split(" ")
N,K=int(input_line[0]),int(input_line[1])
P=input().split(" ")
cumsum=[0]
tol=0
for i in range(N):
P[i]=(int(P[i])+1)/2
tol=tol+P[i]
cumsum.append(tol)
k_sum=[]
for i in range(N-K+1):
k_sum.append(cumsum[i+K]-cumsum[i])
ans=max(k_sum)
print(ans)
|
[
"control_flow.loop.range.bounds.upper.change",
"expression.operation.binary.add"
] | 579,724
| 579,725
|
u309469516
|
python
|
p02780
|
N, K = map(int, input().split())
P = list(map(int, input().split()))
# print( (max(sum(P[i:i+K]) for i in range(0, N-K+1)) + K)/2 )
result = 0
tmp = sum(P[0:K])
for i in range(1, N-K+1):
tmp += (P[i+K-1] - P[i-1])
if (tmp > result):
result = tmp
print((result+K)/2)
|
N, K = map(int, input().split())
P = list(map(int, input().split()))
# print( (max(sum(P[i:i+K]) for i in range(0, N-K+1)) + K)/2 )
tmp = sum(P[0:K])
result = tmp
for i in range(1, N-K+1):
tmp += (P[i+K-1] - P[i-1])
if (tmp > result):
result = tmp
print((result+K)/2)
|
[
"assignment.remove",
"assignment.add"
] | 579,765
| 579,766
|
u603067482
|
python
|
p02780
|
N,K=list(map(int,input().split()))
p=list(map(int,input().split()))
e=[(x+1)/2 for x in p]
tmp=sum(e[0:K])
ans=tmp
for i in range(K,N):
tmp+=e[i]-e[i-K]
ans=max(ans,tmp)
print(tmp)
|
N,K=list(map(int,input().split()))
p=list(map(int,input().split()))
e=[(x+1)/2 for x in p]
tmp=sum(e[0:K])
ans=tmp
for i in range(K,N):
tmp+=e[i]-e[i-K]
ans=max(ans,tmp)
print(ans)
|
[
"identifier.change",
"call.arguments.change",
"io.output.change"
] | 579,775
| 579,776
|
u602773379
|
python
|
p02780
|
N, K = map(int, input().split())
plist = [((num*(num+1))//2)/num for num in list(map(int, input().split()))]
print(plist)
ans = 0
for i in range(K):
ans += plist[i]
_ = ans
for i in range(N-K):
temp = _
temp -= plist[i]
temp += plist[i+K]
# print(i, i+K, ans, temp)
ans = max(ans, temp)
_ = temp
print(ans)
|
N, K = map(int, input().split())
plist = [((num*(num+1))//2)/num for num in list(map(int, input().split()))]
# print(plist)
ans = 0
for i in range(K):
ans += plist[i]
_ = ans
for i in range(N-K):
temp = _
temp -= plist[i]
temp += plist[i+K]
# print(i, i+K, ans, temp)
ans = max(ans, temp)
_ = temp
print(ans)
|
[
"call.remove"
] | 579,777
| 579,778
|
u762420987
|
python
|
p02780
|
# -*- coding: utf-8 -*-
def calc_kitaiti(n):
sum_n = 0
if n % 2 == 0:
temp = n / 2
sum_n = (temp * n) + temp
else:
temp = (n - 1) / 2
sum_n = (n * (temp + 1))
return sum_n / n
def main():
n, k = map(int, input().split())
a = list(map(int, input().split()))
kitaitis = []
pre = 0
for _a in a:
pre += calc_kitaiti(_a)
kitaitis.append(pre)
result = 0
for i in range(k - 1, n):
start = i - k
result = max(result, kitaitis[i] - kitaitis[start])
return result
if __name__ == '__main__':
print(main())
|
# -*- coding: utf-8 -*-
def calc_kitaiti(n):
sum_n = 0
if n % 2 == 0:
temp = n / 2
sum_n = (temp * n) + temp
else:
temp = (n - 1) / 2
sum_n = (n * (temp + 1))
return sum_n / n
def main():
n, k = map(int, input().split())
a = list(map(int, input().split()))
kitaitis = [0]
pre = 0
for _a in a:
pre += calc_kitaiti(_a)
kitaitis.append(pre)
result = 0
for i in range(k, n + 1):
start = i - k
result = max(result, kitaitis[i] - kitaitis[start])
return result
if __name__ == '__main__':
print(main())
|
[
"expression.operation.binary.remove"
] | 579,794
| 579,795
|
u852210959
|
python
|
p02780
|
n,k = map(int, input().split())
p = list(map(int, input().split()))
from itertools import accumulate
cum = list(accumulate(p))
ans = 0
for i in range(n-k):
ans = max(ans, cum[i+k]-cum[i])
print((ans+k)/2)
|
n,k = map(int, input().split())
p = list(map(int, input().split()))
from itertools import accumulate
cum = [0] + list(accumulate(p))
ans = 0
for i in range(n-k+1):
ans = max(ans, cum[i+k]-cum[i])
print((ans+k)/2)
|
[
"assignment.change",
"control_flow.loop.range.bounds.upper.change",
"expression.operation.binary.add"
] | 579,808
| 579,809
|
u744034042
|
python
|
p02780
|
from itertools import accumulate
n,k=map(int,input().split())
p=list(map(int,input().split()))
x=[]
for i in p:
x.append((i+1)/2)
b=list(accumulate(x))
ans=0
for i in range(n-k):
ans=max(ans,b[i+k]-b[i])
print(ans)
|
from itertools import accumulate
n,k=map(int,input().split())
p=list(map(int,input().split()))
x=[]
for i in p:
x.append((i+1)/2)
b=[0]+list(accumulate(x))
ans=0
for i in range(n-k+1):
ans=max(ans,b[i+k]-b[i])
print(ans)
|
[
"assignment.change",
"control_flow.loop.range.bounds.upper.change",
"expression.operation.binary.add"
] | 579,810
| 579,811
|
u094191970
|
python
|
p02780
|
n,k = map(int,input().split())
num_list = list(map(int , input().split()))
candidate = 0
for i in range(n-k):
if i == 0:
for j in range(k):
candidate += (num_list[j]+1)/2
tmp = candidate
else:
tmp += -(num_list[i-1]+1)/2 + (num_list[i+k]+1)/2
if tmp > candidate:
candidate = tmp
print(candidate)
|
n,k = map(int,input().split())
num_list = list(map(int , input().split()))
candidate = 0
for i in range(n-k+1):
if i == 0:
for j in range(k):
candidate += (num_list[j]+1)/2
tmp = candidate
else:
tmp += -(num_list[i-1]+1)/2 + (num_list[i+k-1]+1)/2
if tmp > candidate:
candidate = tmp
print(candidate)
|
[
"control_flow.loop.range.bounds.upper.change",
"expression.operation.binary.add"
] | 579,816
| 579,817
|
u549383771
|
python
|
p02780
|
#abc154 d
n,k=map(int,input().split())
p=list(map(int,input().split()))
r=[0]*(n+1)
s=0
for i in range(n):
s+=p[i]
r[i+1]=s
print(r)
def kitaichi(x):
return (k+x)/2
ans=0
for i in range(n-k+1):
kitai=r[i+k]-r[i]
ans=max(kitai,ans)
print(kitaichi(ans))
|
#abc154 d
n,k=map(int,input().split())
p=list(map(int,input().split()))
r=[0]*(n+1)
s=0
for i in range(n):
s+=p[i]
r[i+1]=s
def kitaichi(x):
return (k+x)/2
ans=0
for i in range(n-k+1):
kitai=r[i+k]-r[i]
ans=max(kitai,ans)
print(kitaichi(ans))
|
[
"call.remove"
] | 579,834
| 579,835
|
u723583932
|
python
|
p02780
|
n, k = list(map(int, input().split()))
p = list(map(int, input().split()))
ans = [0] * n
ans = 0
for i in range(n):
ans[i] = (p[i] + 1) / 2
ruiseki = [0] * (n + 1)
for i in range(n):
ruiseki[i + 1] = ruiseki[i] + ans[i]
res = 0
for i in range(n):
if k+i > n:
break
res = max(res, ruiseki[k + i] - ruiseki[i])
print(res)
|
n, k = list(map(int, input().split()))
p = list(map(int, input().split()))
ans = [0] * n
for i in range(n):
ans[i] = (p[i] + 1) / 2
ruiseki = [0] * (n + 1)
for i in range(n):
ruiseki[i + 1] = ruiseki[i] + ans[i]
res = 0
for i in range(n):
if k+i > n:
break
res = max(res, ruiseki[k + i] - ruiseki[i])
print(res)
|
[
"assignment.remove"
] | 579,851
| 579,852
|
u794173881
|
python
|
p02780
|
N, K = map(int, input().split())
P = [(int(i)+1)/2 for i in input().split()]
wa_temp = sum(P[0:K])
max_wa = wa_temp
for i in range(N-K):
wa_temp = wa_temp - P[i] + P[i+K]
if wa_temp > max_wa:
max_wa = wa_temp
print(max_wa)
print(max_wa)
|
N, K = map(int, input().split())
P = [(int(i)+1)/2 for i in input().split()]
wa_temp = sum(P[0:K])
max_wa = wa_temp
for i in range(N-K):
wa_temp = wa_temp - P[i] + P[i+K]
if wa_temp > max_wa:
max_wa = wa_temp
print(max_wa)
|
[
"call.remove"
] | 579,863
| 579,864
|
u727148417
|
python
|
p02780
|
n,k=map(int,input().split())
P=list(map(int,input().split()))
dp=[0]*(n+1)
for i in range(n):
dp[i+1]=dp[i]+P[i]
ma=0
for i in range(1,n-k+1):
ma=max(ma,dp[i+k]-dp[i])
print((ma+k)/2)
|
n,k=map(int,input().split())
P=list(map(int,input().split()))
dp=[0]*(n+1)
for i in range(n):
dp[i+1]=dp[i]+P[i]
ma=0
for i in range(n-k+1):
ma=max(ma,dp[i+k]-dp[i])
print((ma+k)/2)
|
[
"call.arguments.change"
] | 579,867
| 579,868
|
u573754721
|
python
|
p02780
|
n,k=map(int,input().split())
P=list(map(int,input().split()))
dp=[0]*(n+1)
for i in range(n+1):
dp[i+1]+=dp[i]+P[i]
ans=0
for i in range(n-k+1):
ans=max(ans,dp[i+k]-dp[i])
print((ans+k)/2)
|
n,k=map(int,input().split())
P=list(map(int,input().split()))
dp=[0]*(n+1)
for i in range(n):
dp[i+1]+=dp[i]+P[i]
ans=0
for i in range(n-k+1):
ans=max(ans,dp[i+k]-dp[i])
print((ans+k)/2)
|
[
"expression.operation.binary.remove"
] | 579,869
| 579,870
|
u573754721
|
python
|
p02780
|
n,k=map(int,input().split())
P=list(map(int,input().split()))
S=[0]*(n+1)
for i in range(n):
S[i+1]=S[i]+P[i]
ans=0
for i in range(n-k+1):
ans=max(ans,S[i+k]-S[i])
print((ans+k)//2)
|
n,k=map(int,input().split())
P=list(map(int,input().split()))
S=[0]*(n+1)
for i in range(n):
S[i+1]=S[i]+P[i]
ans=0
for i in range(n-k+1):
ans=max(ans,S[i+k]-S[i])
print((ans+k)/2)
|
[
"expression.operator.arithmetic.change",
"call.arguments.change",
"expression.operation.binary.change",
"io.output.change"
] | 579,871
| 579,872
|
u573754721
|
python
|
p02780
|
n, k = map(int, input().split())
p = list(map(int, input().split()))
e = []
max_ = 0
sum_ = 0
f = []
e = [(1+p[i])/2 for i in range(n)]
for i in range(n):
if i < k:
sum_ += e[i]
else:
sum_ = sum_ + e[i] - e[i - k]
max_ = max(max_, sum_)
print(max_)
|
n, k = map(int, input().split())
p = list(map(int, input().split()))
e = []
max_ = 0
sum_ = 0
f = []
e = [(1+p[i])/2 for i in range(n)]
for i in range(n):
if i < k:
sum_ += e[i]
max_ = sum_
else:
sum_ = sum_ + e[i] - e[i - k]
max_ = max(max_, sum_)
print(max_)
|
[
"assignment.add"
] | 579,881
| 579,882
|
u723345499
|
python
|
p02780
|
n, k = map(int, input().split())
p = list(map(int, input().split()))
ans = 0
for i in range(k):
ans += (p[i] + 1) / 2
calc = ans
print(ans)
for i in range(1, n - k + 1):
calc += ((p[i + k - 1] + 1) - (p[i - 1] + 1)) / 2
ans = max(ans, calc)
print(ans)
|
n, k = map(int, input().split())
p = list(map(int, input().split()))
ans = 0
for i in range(k):
ans += (p[i] + 1) / 2
calc = ans
for i in range(1, n - k + 1):
calc += ((p[i + k - 1] + 1) - (p[i - 1] + 1)) / 2
ans = max(ans, calc)
print(ans)
|
[
"call.remove"
] | 579,887
| 579,888
|
u502731482
|
python
|
p02780
|
n, k = map(int, input().split())
a = list(map(int, input().split()))
cur = 0
for i in range(k):
cur += (a[i]+1)/2
maximum = 0
for i in range(1, n-k+1):
cur -= (a[i-1]+1)/2
cur += (a[i+k-1]+1)/2
maximum = max(maximum, cur)
print(maximum)
|
n, k = map(int, input().split())
a = list(map(int, input().split()))
cur = 0
for i in range(k):
cur += (a[i]+1)/2
maximum = cur
for i in range(1, n-k+1):
cur -= (a[i-1]+1)/2
cur += (a[i+k-1]+1)/2
maximum = max(maximum, cur)
print(maximum)
|
[
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 579,891
| 579,892
|
u652081898
|
python
|
p02780
|
n, k = map(int, input().split())
a = list(map(int, input().split()))
cur = 0
for i in range(k):
cur += (a[i]+1)/2
maximum = 0
for i in range(1, n-k+1):
cur -= (a[i-1]+1)/2
cur += (a[i+k-1])/2
maximum = max(maximum, cur)
print(maximum)
|
n, k = map(int, input().split())
a = list(map(int, input().split()))
cur = 0
for i in range(k):
cur += (a[i]+1)/2
maximum = cur
for i in range(1, n-k+1):
cur -= (a[i-1]+1)/2
cur += (a[i+k-1]+1)/2
maximum = max(maximum, cur)
print(maximum)
|
[
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 579,893
| 579,892
|
u652081898
|
python
|
p02780
|
n,k = map(int,input().split())
p = list(map(float,input().split()))
for i in range(n) :
p[i] = (p[i]+1)/2
# ans[i] = iを含めてk個前までの期待値の総和
ans = [0 for i in range(n)]
ans[k-1] = sum(p[0:k])
for i in range(k,n) :
ans[i] = ans[i-1] + p[i] - p[i-k]
print(ans)
|
n,k = map(int,input().split())
p = list(map(float,input().split()))
for i in range(n) :
p[i] = (p[i]+1)/2
# ans[i] = iを含めてk個前までの期待値の総和
ans = [0 for i in range(n)]
ans[k-1] = sum(p[0:k])
for i in range(k,n) :
ans[i] = ans[i-1] + p[i] - p[i-k]
print(max(ans))
|
[
"call.arguments.add",
"call.arguments.change"
] | 579,896
| 579,897
|
u454557108
|
python
|
p02780
|
n,k = map(int,input().split())
p = list(map(float,input().split()))
for i in range(n) :
p[i] = (p[i]+1)/2
ans = [0 for i in range(n)]
ans[k-1] = sum(p[0:k])
for i in range(k,n-k+1) :
ans[i] = ans[i-1] + p[i] - p[i-k]
print(max(ans))
|
n,k = map(int,input().split())
p = list(map(float,input().split()))
for i in range(n) :
p[i] = (p[i]+1)/2
# ans[i] = iを含めてk個前までの期待値の総和
ans = [0 for i in range(n)]
ans[k-1] = sum(p[0:k])
for i in range(k,n) :
ans[i] = ans[i-1] + p[i] - p[i-k]
print(max(ans))
|
[
"expression.operation.binary.remove"
] | 579,898
| 579,897
|
u454557108
|
python
|
p02780
|
def __main():
n,k = map(int, input().split())
P = list(map(int, input().split()))
P = list(map(lambda x:(x+1)/2, P))
cur = sum(P[:k])
#print('first ', cur)
ans = 0
for i in range(1, n-k+1):
cur += P[i+k-1] - P[i-1]
if cur < ans: continue
ans = cur
print(ans)
__main()
|
def __main():
n,k = map(int, input().split())
P = list(map(int, input().split()))
P = list(map(lambda x:(x+1)/2, P))
cur = sum(P[:k])
#print('first ', cur)
ans = cur
for i in range(1, n-k+1):
cur += P[i+k-1] - P[i-1]
if cur < ans: continue
ans = cur
print(ans)
__main()
|
[
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 579,903
| 579,904
|
u131944095
|
python
|
p02780
|
n,k = map(int, input().split())
p = [int(e) for e in input().split()]
s = sum(p[0:k])
max = 0
for i in range(n-k):
s = s - p[i] + p[i+k]
if max < s:
max = s
ex = float(max+k)/2.000000000000
print(ex)
|
n,k = map(int, input().split())
p = [int(e) for e in input().split()]
s = sum(p[0:k])
max = s
for i in range(n-k):
s = s - p[i] + p[i+k]
if max < s:
max = s
ex = (max+k)/2.0
print(ex)
|
[
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"literal.number.float.change",
"expression.operation.binary.change"
] | 579,920
| 579,921
|
u975820355
|
python
|
p02780
|
n,k = map(int, input().split())
p = [int(e) for e in input().split()]
s = sum(p[0:k])
max = 0
for i in range(n-k):
s = s - p[i] + p[i+k]
if max < s:
max = s
print((max+k)/2.0)
|
n,k = map(int, input().split())
p = [int(e) for e in input().split()]
s = sum(p[0:k])
max = s
for i in range(n-k):
s = s - p[i] + p[i+k]
if max < s:
max = s
ex = (max+k)/2.0
print(ex)
|
[
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"call.add"
] | 579,922
| 579,921
|
u975820355
|
python
|
p02780
|
A = list(map(int , input().split()))
B = list(map(int , input().split()))
kitaiti =[(i+1)/2 for i in B]
ans = []
dd = [0]
for i in range(A[0]):
dd.append(dd[i] + kitaiti[i])
for i in range(A[1] , A[0]):
ans.append(dd[i] - dd[i - A[1]])
print(max(ans))
|
A = list(map(int , input().split()))
B = list(map(int , input().split()))
kitaiti =[(i+1)/2 for i in B]
ans = []
dd = [0]
for i in range(A[0]):
dd.append(dd[i] + kitaiti[i])
for i in range(A[1] , A[0]+1):
ans.append(dd[i] - dd[i - A[1]])
print(max(ans))
|
[
"control_flow.loop.range.bounds.upper.change",
"expression.operation.binary.add"
] | 579,950
| 579,951
|
u140191608
|
python
|
p02780
|
from sys import stdin
def get_result(data):
N, K = data[0]
A = data[1]
e_val = [(1 + val) / 2 for val in A]
# 累積和を算出 (最初は0)
e_cumsum = [0]
for i in range(N):
e_cumsum.append(e_cumsum[i] + e_val[i])
# 隣接するK個の部分和を取得
e_sum_k = []
for i in range(N-K):
e_sum_k.append(e_cumsum[i+K] - e_cumsum[i])
return max(e_sum_k)
if __name__ == '__main__':
raw_data = [val.rstrip('\n') for val in stdin.readlines()]
data = [list(map(int, val.split(' '))) for val in raw_data]
result = get_result(data)
print(result)
|
from sys import stdin
def get_result(data):
N, K = data[0]
A = data[1]
e_val = [(1 + val) / 2 for val in A]
# 累積和を算出 (最初は0)
e_cumsum = [0]
for i in range(N):
e_cumsum.append(e_cumsum[i] + e_val[i])
# 隣接するK個の部分和を取得
e_sum_k = []
for i in range(N+1-K):
e_sum_k.append(e_cumsum[i+K] - e_cumsum[i])
return max(e_sum_k)
if __name__ == '__main__':
raw_data = [val.rstrip('\n') for val in stdin.readlines()]
data = [list(map(int, val.split(' '))) for val in raw_data]
result = get_result(data)
print(result)
|
[
"control_flow.loop.range.bounds.upper.change",
"expression.operation.binary.add"
] | 579,952
| 579,953
|
u659302753
|
python
|
p02780
|
N,K=map(int,input().split())
p=list(map(int,input().split()))
a=0
for j in range(K):
a+=(1+p[j])/2
Max=a
for i in range(K-1,N):
a=a+(p[i]-p[i-K+1])/2
if Max<a:
Max=a
print(Max)
|
N,K=map(int,input().split())
p=list(map(int,input().split()))
a=0
for j in range(K):
a+=(1+p[j])/2
Max=a
for i in range(K,N):
a=a+(p[i]-p[i-K])/2
if Max<a:
Max=a
print(Max)
|
[
"expression.operation.binary.remove"
] | 579,958
| 579,959
|
u265506056
|
python
|
p02780
|
n,k = map(int,input().split())
ps = [0]*n
ps = list(map(lambda x: (int(x)+1) / 2,input().split()))
print(ps)
ans = 0
for i in range(k):
ans += ps[i]
tmp = ans
for i in range(k,n):
tmp = tmp - ps[i-k] + ps[i]
if ans < tmp:
ans = tmp
print(ans)
|
n,k = map(int,input().split())
ps = [0]*n
ps = list(map(lambda x: (int(x)+1) / 2,input().split()))
ans = 0
for i in range(k):
ans += ps[i]
tmp = ans
for i in range(k,n):
tmp = tmp - ps[i-k] + ps[i]
if ans < tmp:
ans = tmp
print(ans)
|
[
"call.remove"
] | 579,987
| 579,988
|
u925712873
|
python
|
p02780
|
n, k = map(int, input().split())
p = [int(x) for x in input().split()]
M = 0
for i in range(k):
M += (1 + p[i]) / 2
e = M
for i in range(n-k):
e -= (1 + p[i]) / 2
e += (1 + p[i+k]) / 2
if e > M:
M = e
print('{%.12f}'.format(M))
|
n, k = map(int, input().split())
p = [int(x) for x in input().split()]
M = 0
for i in range(k):
M += (1 + p[i]) / 2
e = M
for i in range(n-k):
e -= (1 + p[i]) / 2
e += (1 + p[i+k]) / 2
if e > M:
M = e
print('{:.12f}'.format(M))
|
[
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 579,989
| 579,990
|
u545411641
|
python
|
p02780
|
n,k=map(int,input().split())
A=list(map(int,input().split()))
for i in range(n):
A[i]=(1+A[i])/2
S=[0 for i in range(n+1)]
for i in range(n):
S[i+1]=S[i]+A[i]
ans=0
for i in range(n-k):
ans=max(ans,S[i+k]-S[i])
print(ans)
|
n,k=map(int,input().split())
A=list(map(int,input().split()))
for i in range(n):
A[i]=(1+A[i])/2
S=[0 for i in range(n+1)]
for i in range(n):
S[i+1]=S[i]+A[i]
ans=0
for i in range(n-k+1):
ans=max(ans,S[i+k]-S[i])
print(ans)
|
[
"control_flow.loop.range.bounds.upper.change",
"expression.operation.binary.add"
] | 580,035
| 580,036
|
u023229441
|
python
|
p02780
|
n,k=map(int,input().split())
A=list(map(int,input().split()))
for i in range(n):
A[i]=(1+A[i])/2
S=[0 for i in range(n+1)]
for i in range(n):
S[i+1]=S[i]+A[i]
ans=0
for i in range(n-k+1):
ans=max(ans,S[i+k]-S[i-1])
print(ans)
|
n,k=map(int,input().split())
A=list(map(int,input().split()))
for i in range(n):
A[i]=(1+A[i])/2
S=[0 for i in range(n+1)]
for i in range(n):
S[i+1]=S[i]+A[i]
ans=0
for i in range(n-k+1):
ans=max(ans,S[i+k]-S[i])
print(ans)
|
[
"expression.operation.binary.remove"
] | 580,037
| 580,036
|
u023229441
|
python
|
p02780
|
N, K =map(int, input().split())
p = list(map(int, input().split()))
c=[(i+1)/2 for i in p]
d =sum(c[:K])
e =d
for i in range(N-K):
d -= c[i]
d += c[i+K]
if e>d:
d=e
print(d)
|
N, K =map(int, input().split())
p = list(map(int, input().split()))
c=[(i+1)/2 for i in p]
d =sum(c[:K])
e =d
for i in range(N-K):
e -= c[i]
e += c[i+K]
if e>d:
d=e
print(d)
|
[
"identifier.change"
] | 580,038
| 580,039
|
u940516059
|
python
|
p02780
|
n,k=list(map(int,input().split()))
li=list(map(int,input().split()))
sum_=0
for i in range(k):
sum_+=li[i]
max_=sum_
for i in range(k+1,len(li)):
sum_-=li[i-k-1]
sum_+=li[i]
if max_<sum_:
max_=sum_
max_+=k
max_/=2
print(max_)
|
n,k=list(map(int,input().split()))
li=list(map(int,input().split()))
sum_=0
for i in range(k):
sum_+=li[i]
max_=sum_
for i in range(k,len(li)):
sum_-=li[i-k]
sum_+=li[i]
if max_<sum_:
max_=sum_
max_+=k
max_/=2
print(max_)
|
[
"expression.operation.binary.remove"
] | 580,040
| 580,041
|
u222643068
|
python
|
p02780
|
n = input().split()
N = int(n[0])
K = int(n[1])
a = input().split()
sum = 0
max = 0
for j in range(0, N):
sum += int(a[j])
if j > K - 1:
sum -= int(a[j - K])
if max < sum:
max = sum
print ((max + K) / 2)
|
n = input().split()
N = int(n[0])
K = int(n[1])
a = input().split()
sum = 0.0
max = 0.0
for j in range(0, N):
sum += float(a[j])
if j > K - 1:
sum -= float(a[j - K])
if max < sum:
max = sum
print ((max + K) / 2)
|
[
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 580,048
| 580,049
|
u781163713
|
python
|
p02780
|
N, K = map(int,input().split())
p = [0] + [int(x) for x in input().split()]
p = [(x+1)//2 for x in p]
for i in range(N):
p[i+1] += p[i]
ans = 0
for i in range(K, N+1):
ans = max(ans, p[i]-p[i-K])
print(ans)
|
N, K = map(int,input().split())
p = [0] + [int(x) for x in input().split()]
p = [(x+1)/2 for x in p]
for i in range(N):
p[i+1] += p[i]
ans = 0
for i in range(K, N+1):
ans = max(ans, p[i]-p[i-K])
print(ans)
|
[
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 580,054
| 580,055
|
u393512980
|
python
|
p02780
|
a,b=map(int,input().split())
d = list(map(int, input().split(" ")))
w = [0]*(len(d)+1)
# 累積和の計算
w[0] = 0
for i in range(0, len(d)):
w[i+1] = w[i] + d[i]
print(w)
ans = 0
for i in range(0, a-b+1):
ans = max([ans,w[i+b]-w[i]])
d2 = 0.5*b + ans/2
if a == 1:
print((d[0]+1)/2)
else:
print(d2)
|
a,b=map(int,input().split())
d = list(map(int, input().split(" ")))
w = [0]*(len(d)+1)
# 累積和の計算
w[0] = 0
for i in range(0, len(d)):
w[i+1] = w[i] + d[i]
ans = 0
for i in range(0, a-b+1):
ans = max([ans,w[i+b]-w[i]])
d2 = 0.5*b + ans/2
if a == 1:
print((d[0]+1)/2)
else:
print(d2)
|
[
"call.remove"
] | 580,056
| 580,057
|
u178465329
|
python
|
p02780
|
n,k=map(int,input().split())
p=list(map(int,input().split()))
def g(x):
return (1+x)/2
a=[]
ans=0
f=0
for i in range(k):
f+=g(p[i])
a.append(f)
for i in range(n-k):
a.append(a[i]+g(p[k+i])-g(p[i]))
ans=max(ans,a[i+1])
print(ans)
|
n,k=map(int,input().split())
p=list(map(int,input().split()))
def g(x):
return (1+x)/2
a=[]
ans=0
f=0
for i in range(k):
f+=g(p[i])
a.append(f)
ans=f
for i in range(n-k):
a.append(a[i]+g(p[k+i])-g(p[i]))
ans=max(ans,a[i+1])
print(ans)
|
[
"assignment.add"
] | 580,058
| 580,059
|
u588558668
|
python
|
p02780
|
n,k=map(int,input().split())
p=list(map(int,input().split()))
def g(x):
return (1+x)/2
a=[]
ans=0
f=0
for i in range(k):
f+=g(p[i])
a.append(f)
for i in range(n-k+1):
a.append(a[i]+g(p[k+i])-g(p[i]))
ans=max(ans,a[i+1])
print(ans)
|
n,k=map(int,input().split())
p=list(map(int,input().split()))
def g(x):
return (1+x)/2
a=[]
ans=0
f=0
for i in range(k):
f+=g(p[i])
a.append(f)
ans=f
for i in range(n-k):
a.append(a[i]+g(p[k+i])-g(p[i]))
ans=max(ans,a[i+1])
print(ans)
|
[
"expression.operation.binary.remove"
] | 580,061
| 580,059
|
u588558668
|
python
|
p02780
|
n,k=map(int,input().split())
p=list(map(int,input().split()))
def g(x):
return (1+x)/2
a=[]
ans=0
f=0
for i in range(k):
f+=g(p[i])
a.append(f)
for i in range(n-k):
a.append(a[i]+g(p[k+i])-g(p[i]))
ans=max(ans,a[i+1])
print(ans)
|
n,k=map(int,input().split())
p=list(map(int,input().split()))
def g(x):
return (1+x)/2
a=[]
ans=0
f=0
for i in range(k):
f+=g(p[i])
a.append(f)
ans=f
for i in range(n-k):
a.append(a[i]+g(p[k+i])-g(p[i]))
ans=max(ans,a[i+1])
print(ans)
|
[
"assignment.add"
] | 580,062
| 580,059
|
u588558668
|
python
|
p02780
|
n,k=map(int,input().split())
p=list(map(int,input().split()))
def g(x):
return (1+x)/2
a=[]
ans=0
f=0
for i in range(k):
f+=g(p[i])
a.append(f)
for i in range(n-k):
a.append(a[i]+g(p[k])-g(p[i]))
ans=max(ans,a[i+1])
print(ans)
|
n,k=map(int,input().split())
p=list(map(int,input().split()))
def g(x):
return (1+x)/2
a=[]
ans=0
f=0
for i in range(k):
f+=g(p[i])
a.append(f)
ans=f
for i in range(n-k):
a.append(a[i]+g(p[k+i])-g(p[i]))
ans=max(ans,a[i+1])
print(ans)
|
[
"assignment.add",
"expression.operation.binary.add"
] | 580,063
| 580,059
|
u588558668
|
python
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.