return the sum of the max sublist - list

Question

I have to write a function that takes a list of integers and returns the maximum sum sublist of the list. An example would be:
l = [4,-2,-8,5,-2,7,7,2,-6,5]
returns 19
so far my code is:
count = 0
for i in range(0,len(l)-1):
for j in range(i,len(l)-1):
if l[i] >= l[j]:
count += l[i:j]
return count
I am kind of stuck and confused, can anyone help?
Thank You!

Answer 1

I assume this is a homework, so I won't try to google algorithms here and/or post too much code.
Some ideas (just from the top of my head, 'cause I like these kind of tasks :-))
As user lc already pointed out the naive, and also exhaustive way is to test every single sublist. I believe your (user2101463) code goes in that direction. Just use sum() to build up the sums and compare against a known best. To prime the best known sum with a reasonable starting value, just use the first value of the list.
the_list = [4,-2,-8,5,-2,7,7,2,-6,5]
best_value = the_list[0]
best_idx = (0,0)
for start_element in range(0, len(the_list)+1):
for stop_element in range(start_element+1, len(the_list)+1):
sum_sublist = sum(the_list[start_element:stop_element])
if sum_sublist > best_value:
best_value = sum_sublist
best_idx = (start_element, stop_element)
print("sum(list([{}:{}])) yields the biggest sum of {}".format(best_idx[0], best_idx[1], best_value))
This of course has quadratic runtime O(N^2). That means: If the problem size, as defined by the number of elements of the input list, grows with N, the runtime grows with N*N, with some arbitrary coefficients.
Some heuristics for improvement:
Obviously negative numbers are not good because they decrease the achievable sum
If you encounter a sequence of negative numbers, restart your best sublist after that sequence, if the sum of the best list so far plus the negative numbers is < 0. In your example list the first three numbers cannot be part of a best list because the positive effect of the 4 is always negated by the -2, -8.
Possibly this even leads to an O(N) implementation which just iterates from start to end, memorizing the best known start index while calculating running sums of a full total from that start index as well as positive and negative subtotals of the last continues sequence of positive and negative numbers, respectively.
Once such a best list is found, possibly this requires a final cleanup to remove a trailing negative sublist such as the -6, 5 at the end of your example.
Hope this leads in the right direction.

Answer 2

This is called the 'maximum subarray problem' and can be done in linear time. The wikipedia article has your answer.

Answer 3

The most optimal solution is which takes linear runtime that is O(n).But this problem has "n*lgn" runtime solution(based on divide and conquer algorithm) and "n^2" runtime solution.If you are interested in those algorithms here is the link introduction to algorithms which is highly recommended and here I write a code in java which has linear runtime.
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int []A=new int[n];
int highestsum=Integer.MIN_VALUE;
int sumvariable=0;
int x=0;
for(int i=0;i<n;i++)
{
A[i]=sc.nextInt();
}
for(int i=0;i<n;i++)
{
sumvariable+=A[i];
if(sumvariable<0)
{
if(sumvariable>=highestsum)
{
highestsum=A[i];
sumvariable=A[i];
}
else
{
sumvariable=0;
}
}
else
{
if(sumvariable>highestsum)
{
highestsum=sumvariable;
}
}
}
System.out.println(highestsum);
}