Bug in the posted code. If you try it with the input [1,0,1,0,0] you will get the answer 1. The first two lines in the else won't get executed if the sequence ends with the longest run of zeros. Correct code is

 for j in l:
 if j==0:
 c+=1
 else:
 c = 0
 if c > max_count:
 max_count = c

 return max_count

This can be considerably shortened and, I think, clarified:

 for j in l:
 c = c + 1 if j==0 else 0 # in other languages there is a ternary ?: op
 max_count = max( max_count, c) 

 return max_count

Two stylistic issues:

never use l as a variable name, it reads like 1. Lowercase l is best avoided altogether unless it's part of a word in a natural language. Similar arguments against O and Z which read like 0 and 2, but class-names starting with capital O or Z aren't so confusing.

The Pythonic form of initialization is c, max_count = 0, 0 (one line) provided the right-hand side, in particular, needs no real thought.

First the good: your code provides a testable function. So let's add some test code

def largest_row_of_zeros(l):
 '''
 >>> largest_row_of_zeros([])
 0
 >>> largest_row_of_zeros([0])
 1
 >>> largest_row_of_zeros([1])
 0
 >>> largest_row_of_zeros([0, 0])
 2
 >>> largest_row_of_zeros([0, 1])
 1
 >>> largest_row_of_zeros([1, 0])
 1
 >>> largest_row_of_zeros([1, 1])
 0
 '''

 c = 0
 max_count = 0
 for j in l:
 if j==0:
 c+=1
 else:
 if c > max_count:
 max_count = c
 c = 0
 return max_count


if __name__ == "__main__":
 import doctest
 doctest.testmod()

which gives

Python 3.6.1 (default, Dec 2015, 13:05:11)
[GCC 4.8.2] on linux
**********************************************************************
File "main.py", line 5, in __main__.largest_row_of_zeros
Failed example:
 largest_row_of_zeros([0])
Expected:
 1
Got:
 0
**********************************************************************
File "main.py", line 9, in __main__.largest_row_of_zeros
Failed example:
 largest_row_of_zeros([0, 0])
Expected:
 2
Got:
 0
**********************************************************************
File "main.py", line 13, in __main__.largest_row_of_zeros
Failed example:
 largest_row_of_zeros([1, 0])
Expected:
 1
Got:
 0
**********************************************************************
1 items had failures:
 3 of 7 in __main__.largest_row_of_zeros
***Test Failed*** 3 failures.

Here I use doctest. Another very common module is unittest. But you could also use simple assertions

if __name__ == "__main__":
 assert largest_row_of_zeros([0]) == 1

Have fun with testing.

To simplify the code you can:

1. You can use itertools.groupby to group the runs of 1s and 0s.


2. Filter if these groups to ones just containing zero.


3. Find the length of each group.


4. Return the maximum.

import itertools


def largest_row_of_zeros(l):
 return max(len(list(g)) for k, g in itertools.groupby(l) if k == 0)

In your code I would move the max aspect of the code out of the function and make the original a generator function. This allows you to use max to simplify the handling of the data.

def zero_groups(l):
 c = 0
 for j in l:
 if j == 0:
 c += 1
 else:
 yield c
 c = 0


def largest_row_of_zeros(l):
 return max(zero_groups(l))

Why check all the elements? You can jump ahead k+1 elements at a time once you find k in a row. After a while you're jumping huge amounts each iteration

def longest_run(arr, element):
 longest = 0
 start = 0
 non_match = -1
 while start < len(arr):
 if arr[start] == element:
 current_run = 1
 while current_run <= longest and arr[start - current_run] == element:
 current_run += 1
 if current_run > longest:
 while non_match + current_run + 1 < len(arr) and arr[non_match + current_run + 1] == element:
 current_run += 1
 longest = current_run
 non_match = non_match + current_run
 else:
 non_match = start - current_run
 else:
 non_match = start
 start = non_match + longest + 1
 return longest

Another alternative: use RLE (run-length-encoding; with thanks to the comments for the correct naming), borrowed originally from a very simple data compressor of the same name.

Here's the code, albeit in the R language. (For non-users, 1L just forces integer-class, x[-k] means all of vector x except index 'k' )

Here's the base package code for the function rle(x) :

First line: generate logical vector of "is x[j] == x[j-1] ? "

 y <- x[-1L] != x[-n] ;

which returns index values when argument is TRUE, and c concatenates vectors (is.na just catches N/A values in case the input was skeevy)

 i <- c(which(y | is.na(y)), n) ; 

finally, create a structure. First element calculates run lengths by comparing sequential index values in i ; second element returns the value of the input vector every time that run terminates

 structure(list(lengths = diff(c(0L, i)), values = x[i]), class = "rle")

then add a line to find max(lengths[values==0]).

Just curious, but if the values list appears as a delimited collection, could you not just strip out the commas and split on the 1's to make an array and then reduce that? I haven't worked in python in 15 years (edit: updated to python) but this code seems to work:

# importing functools for reduce() 
import functools 

# initializing list 
inputString = "1,0,1,1,0,0,0,0,1,0,0"

#remove commas and split result into an array using 1 as the delimiter
inputString = inputString.replace(",", "")
resultArr = inputString.split("1");

# using reduce to compute maximum element from resulting array list 
longestString = (functools.reduce(lambda a,b : a if a >= b else b,resultArr)) 

#output the result
print ("The maximum element of the list is : ",end="") 
print (len(longestString)) 

Wanted to provide an alternate solution to the largest_row_of_zeros method. Easier to understand, but might not be as efficient.

def largest_row_of_zeros():
 asStr = reduce((lambda x, y: str(x) + str(y)), random_list())
 splitted = asStr.split("1")
 return len(max(splitted))

• Basically create a string "1010010101010"
  


• Split at 1s. "","0","00","0" ...


• Get length of longest string