查找列表中的所有子序列

Question

I have a list of 1s and 0s as follows:

lst = [1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 1]

I'm looking for a method that finds all the sequences of 0s within this list and returns their indices, ie:

[1, 3]
[8, 9]
[13, 13]
[15, 16]

This answer shows a method of getting the longest sequence, but I can't think of a way to work from it to get all the sequences.

Answer 1

def f(l):
    _1to0 = [ i+1 for i, (x, y) in enumerate(zip(l[:-1], l[1:])) if y == 0 and x != y ]
    _0to1 = [ i for i, (x, y) in enumerate(zip(l[:-1], l[1:])) if x == 0 and x != y ]
    if l[0] == 0:
      _1to0.insert(0,0)
    if l[-1] == 0:
      _0to1.append(len(l))
    return zip(_1to0, _0to1)

1. Detect changes 1 -> 0 (starts) and 0 -> 1 (ends)

2. If start with 0, add a start at indice 0

3. If ends with 0, add an end at the last indice

4. Combine starts and ends in pairs

    In [1]: list(f([1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 1]))
    Out[1]: [(1, 3), (8, 9), (13, 13), (15, 16)]

Answer 2

For Python 3.8 you can modify the first answer in referenced code by using the Walrus operator

Code

from itertools import groupby
import operator

lst = [1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 1]

r = [(p[1][0][0], p[1][-1][0]) for (x,y) in groupby(enumerate(lst), operator.itemgetter(1)) if (p := (x, list(y)))[0] == 0]
print(r)

Output

[(1, 3), (8, 9), (13, 13), (15, 16)]

Explanation

Adding a Walrus operator to OP code reference we have:

r = [p for (x,y) in groupby(enumerate(lst), operator.itemgetter(1)) if (p := (x, list(y)))[0] == 0]
# Outputs: [(0, [(1, 0), (2, 0), (3, 0)]), (0, [(8, 0), (9, 0)]), (0, [(13, 0)]), (0, [(15, 0), (16, 0)])]

Conditional in the list comprehension:

(p := (x, list(y)))[0] # is a check for x == 0 

Need to capture the right terms in p

First p[1] for instance is:

[(1, 0), (2, 0), (3, 0)]   

We want the (1, 3) which index 0 of the first and last term of the list

p[1][0][0]   # index zero of first tuple -> 1
p[1][-1][0]  # index zero of last tuple  -> 3

So in general we have the tuple:

(p[1][0][0], p[1][-1][0])

Answer 3

list = [1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 1]

indexes_counts = []
start_zero_index = -1
is_inside_zero_sequence = False
zero_length = 0
# Use enumerate to loop on the lists and indexes
for i, x in enumerate(list):
    # If inside a zeroes sequence
    if is_inside_zero_sequence:
        # If current item is zero too
        if 0 == x:
            # Increase the zro_length counter
            zero_length += 1
        # Else, current element is not zero
        else:             
            # Handle end of zeroes sequence
            indexes_counts.append([start_zero_index, zero_length])
            is_inside_zero_sequence = False
            zero_length = 0
    # If not in zeroes sequence and current number is not zero
    elif 0 == x:
            # Handle not zero
            is_inside_zero_sequence = True
            start_zero_index = i
            zero_length = 1

# [[1, 3], [8, 2], [13, 1], [15, 2]]
print(indexes_counts)