Question

我需要编写一个给出整数L和整数n的列表的函数，如果该列表包含长度为{{1}的连续序列，则返回True }和n其他。

比方说我的名单是：False和L = [1,2,3,4,1,1,1,2,3,4] = 3。该函数应返回n，因为在第5位有3个。

我尝试过：

True

但这当然不起作用，因为def consecutive (L,n): for i in range(len(L)): if [1]*n in L: return True return False L = [1,2,3,4,1,1,1,2,3,4] n = 3 consecutive (L,n)会生成[1]*3，并且[1,1,1]中没有子列表。

有什么办法可以使用列表理解功能？像这样：

同样，我知道这是行不通的，因为每个元素L = [1,2,3,4,1,1,1,2,3,4] result = all(x==(1,1,1) for x in range(0,len(L)+1,3)) result不能等于x。我写下来只是为了让我对自己的想法有所了解。

Answer 1

一种方法是使用itertools.groupby，它允许您将列表中的连续值分组。如果找到了key的给定1，并且其相应值的长度是>=比n，则以下生成器理解将返回next。

返回第一个True后，我们可以使用from itertools import groupby n = 3 next((True for k,v in groupby(L) if k == 1 and len(list(v)) >= n), False) # True停止迭代：

spring.jpa.hibernate.ddl-auto=create-drop
spring.datasource.url=jdbc:mysql://192.168.1.88:3306/question?serverTimezone=UTC
spring.datasource.username=luigi
spring.datasource.password=root

Answer 2

不使用导入

例如：

L = [1,2,3,4,1,1,1,2,3,4]
n = 3
def consecutive (L,n):
    c = 0
    for i in L:
        if i == 1:
            c += 1
        else:
            c = 0
        if c >= n:
            return True
    return False


print(consecutive(L,n))

Answer 3

如果您不想导入模块（我想这是家庭作业），则可以执行以下操作：

n = 3
L = [1,2,3,4,1,1,1,2,3,4]
find = [1] * n

locations = [index for index in range(len(L)) if index <= len(L) and L[index: index + len(find)] == find]

for location in locations:
    print(f"Found {find} at index {location}.")

输出：

Found [1, 1, 1] at index 4.

尽管您可能需要考虑做长途旅行，而不是列表理解来学习该语言。

Answer 4

如果想知道任何列表元素是否重复，以下内容将起作用。当且仅当存在任何元素的True个副本序列时，以下命令才会返回n：

def consecutive (L,n):
    if len(L) < 1:
        return False
    if n <= 1:
        return True

    # at this point n >= 2
    elem = L[0]
    count = 1
    # so far, we have seen one copy of `elem`

    for i in range(1, len(L)):
        if L[i] == elem:
            count = count + 1
            if count >= n:
                return True
        else: # L[i] != elem
            elem = L[i]
            count = 1
    return False

如果有一个您想重复的元素，请考虑以下事项：

def consecutive (L,n, elem):
    count = 0
    for i in range(len(L)):
        if L[i] == elem:
            count = count + 1
            if count >= n:
                return True
        else: # L[i] != elem
            count = 0
    return False

Answer 5

正如@yatu所说，使用itertools显然是最好的方法。

但是可以通过压缩原始列表的切片来复制。例如，要将列表项按3分组，您可以执行以下操作：

l = [1, 2, 3, 4, 1, 1, 1, 2, 3, 4]

def groupby3(a_list):
    return zip(a_list[:-2], a_list[1:-1], a_list[2:])

print([l for l in groupby3(l)])
# [(1, 2, 3), (2, 3, 4), (3, 4, 1), (4, 1, 1), (1, 1, 1), (1, 1, 2), (1, 2, 3), (2, 3, 4)]

按任意数量对项目进行分组比较复杂，因为我们必须动态地构建切片：

l = [1, 2, 3, 4, 1, 1, 1, 2, 3, 4]

def groupbyn(a_list, n):
    # computes the bounds of slices to use
    bounds = ((start or None, start - n + 1 or None) for start in range(n))
    # builds a slice for each generated bounds couple
    slices = (slice(start, stop) for start, stop in bounds)
    # apply the generated slices
    sliced = (a_list[slice] for slice in slices)
    # return the sipped slices
    return zip(*sliced)

print([l for l in groupbyn(l, 3)])
# [(1, 2, 3), (2, 3, 4), (3, 4, 1), (4, 1, 1), (1, 1, 1), (1, 1, 2), (1, 2, 3), (2, 3, 4)]
print([l for l in groupbyn(l, 2)])
# [(1, 2), (2, 3), (3, 4), (4, 1), (1, 1), (1, 1), (1, 2), (2, 3), (3, 4)]
print([l for l in groupbyn(l, 5)])
# [(1, 2, 3, 4, 1), (2, 3, 4, 1, 1), (3, 4, 1, 1, 1), (4, 1, 1, 1, 2), (1, 1, 1, 2, 3), (1, 1, 2, 3, 4)]

然后，您可以使用此groupbyn函数来解决您的问题：

n = 3
print((1, ) * n in groupbyn(l, n))  # True
n = 4
print((1, ) * n in groupbyn(l, n))  # False

如何在列表中找到重复元素的连续序列？

5 个答案: