如何在python的列表算法中减少k个连续数字的最大和的执行时间

Question

my problem is to find the maximum sum of k consecutive numbers in a given list. for instance: l = [2,3,5,1,6] then for k =2 the result would be 8(3+5). I know a good algorithm would be to first find the sum of the first k numbers then add the next element to the sum and subtract the first element of the k numbers:

2+3 => 5
5-2+5 => 8
... 

I came up with this:

def f(l, k):
    M= 0
    temp = sum(l[0:k])
    for i in range(1,k):
        temp += a[l+1]-l[i-1]
        if temp > M:
            M = temp
    return M

but unfortunately it only works with k = 2? so I have two issues:

1. Why my code doesn't work with higher k's?(what is the bug and how can I fix it?)
2. Is there any better way(time wise) to solve the main problem?will this algorithm work quick enough if for example len(l) = 100000 and k = 2000?how can I determine its execution time only by looking at the code?

Answer 1

The idea you described is correct, but your implementation is wrong.

1. Your variable M is equivalent to cumax below. It should be initialized to the sum of the first k items, not 0.
2. Your range of the start of the k numbers to consider should be N - k + 1 , the largest position in the sequence for a window of size k.

3. Your temp is equivalent to cusum . The line temp += a[l+1]-l[i-1] is wrong. I don't know where you get a from. I think you meant temp += l[i + k] - l[i - 1] .

    def f(l, k): assert len(l) >= k # Start of max sum of k consecutive number start_idx = 0 # Current max sum of k consecutive number cumax = cusum = sum(l[:k]) # Slide a window of size k from second element onwards N = len(l) for i in range(1, N - k + 1): # Subtract element before start of window and add rightmost element cusum = cusum + l[i + k - 1] - l[i - 1] # Update start of and latest max sum of k consecutive number if # necessary if cusum > cumax: cumax = cusum start_idx = i return start_idx, cumax 

The time complexity is O(N) and memory complexity is O(1). In reality, for long sequences, the approach by @dobkind using convolution would probably be fastest.

def f_convolve(l, k):
    start_idx = np.argmax(np.convolve(l, np.ones(k,), 'valid'))
    return start_idx, np.sum(l[start_idx : start_idx + k])

If you have memory to spare and l is not too large, this implementation works even better than the previous two

def f_numpy_cusum(l, k):
    cumsums = np.cumsum(l)
    cumsums[k :] -= cumsums[: len(cumsums) - k ]
    cumsums = cumsums[ k- 1:]
    start = np.argmax(cumsums)
    return start, np.sum(l[start : start + k])

The time runs for the above 3 functions with len(l) = 100000 and k = 2000 are

f 32.6 ms +- 78.5 us per loop (mean +- std. dev. of 7 runs, 10 loops each)

f_convolve 26.3 ms +- 183 us per loop (mean +- std. dev. of 7 runs, 10 loops each)

f_numpy_cusum 718 us +- 3.81 us per loop (mean +- std. dev. of 7 runs, 1000 loops each)

Answer 2

We should use dynamic programming for this purpose and do this in O(n) complexity

from random import randint

test=[randint(1,10) for i in range(5)]
# find cumulative sum use np.cumsum or write is yourself
print(test)
cumsum=[0]*(len(test)+1)
cumsum[1]=test[0]
for i in range(2,len(test)+1):
    cumsum[i]=cumsum[i-1]+test[i-1]
print(cumsum)
#define k
k=3
# m denotes the maximum element
m=0
for i in range(len(test)-k+1):
   m=max(m,cumsum[k+i]-cumsum[i])
   print(cumsum[k+i]-cumsum[i])
# the answer is printed 
print(m)

INPUT

[10, 5, 1, 1, 7]
k=3

OUTPUT

16

Answer 3

You can use numpy.convolve as follows:

k = 2     
max_sum = np.max(np.convolve([2,3,5,1,6], np.ones(k,), 'same'))

With k=2000 and len(l)=100000 this code is running in 0.04 sec on my i7 machine:

from random import randint
import time

def test_max_sum(k, len_l):
    num_trials = 100
    total = 0
    test = [randint(1, 10) for i in range(len_l)]
    for i in range(num_trials):
        start = time.clock()
        max_sum = np.max(np.convolve(test, np.ones(k, ), 'same'))
        end = time.clock()
        total += end - start
    total /= num_trials
    print total

Answer 4

This is really not my expertise, but wouldnt zipping together the lists be quite effective?

Something in the lines of:

from itertools import islice

l = [2,3,5,1,6]

def max_consecutive(ar, k=2):
    combos = zip(*(islice(ar,i,None) for i in range(k)))
    return max(map(sum, combos))

print(max_consecutive(l)) 
print(max_consecutive(l, k=3))

Returns 8 and 12