Question

我想测试列表是否包含连续的整数而不重复数字。例如，如果我有

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

它应该返回True。

如何在不修改原始列表的情况下检查列表是否包含最多n个连续数字？我想复制列表并删除原始列表中显示的每个数字，如果列表为空，则返回True。

有更好的方法吗？

Answer 1

对于整个列表，它应该像

一样简单

sorted(l) == list(range(min(l), max(l)+1))

这会保留原始列表，但如果您的列表特别长，那么复制（然后排序）可能会很昂贵。

请注意，在Python 2中，您只需使用以下内容，因为range返回了list个对象。在3.x及更高版本中，函数已更改为返回range对象，因此在与list进行比较之前需要显式转换为sorted(l)

sorted(l) == range(min(l), max(l)+1))

要检查n条目是否连续且不重复，它会变得更复杂一些：

def check(n, l):
    subs = [l[i:i+n] for i in range(len(l)) if len(l[i:i+n]) == n]
    return any([(sorted(sub) in range(min(l), max(l)+1)) for sub in subs])

Answer 2

我们可以使用已知的数学公式来检查连续性，假设最小数字总是从1开始

#include <QtWidgets/QtWidgets>
 [...]
class FenetreEdition;

Answer 3

验证列表没有重复项后，只需计算min(l)和max(l)之间的整数之和：

def check(l):
    total = 0
    minimum = float('+inf')
    maximum = float('-inf')

    seen = set()

    for n in l:
        if n in seen:
            return False

        seen.add(n)

        if n < minimum:
            minimum = n

        if n > maximum:
            maximum = n

        total += n

    if 2 * total != maximum * (maximum + 1) - minimum * (minimum - 1):
        return False

    return True

Answer 4

import numpy as np
import pandas as pd    

(sum(np.diff(sorted(l)) == 1) >= n) & (all(pd.Series(l).value_counts() == 1))

我们测试两个条件，首先找到排序列表np.diff(sorted(l))的迭代差异，我们可以测试是否有n个连续整数。最后，我们测试value_counts()是否全部为1，表示没有重复。

Answer 5

第一个代码删除了重复项但保留了顺序：

from itertools import groupby, count

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

def remove_duplicates(values):
    output = []
    seen = set()
    for value in values:
        if value not in seen:
            output.append(value)
            seen.add(value)
    return output

l = remove_duplicates(l) # output = [1, 2, 4, 5, 6, 3]

下一组是从here

中确定哪些是有序的

def as_range(iterable):
    l = list(iterable)
    if len(l) > 1:
        return '{0}-{1}'.format(l[0], l[-1])
    else:
        return '{0}'.format(l[0])

l = ','.join(as_range(g) for _, g in groupby(l, key=lambda n, c=count(): n-next(c)))

l输出为：1-2,4-6,3

您可以根据输出自定义功能。

Answer 6

我将您的查询分为两部分A＆＃34;列表包含最多n个连续数字＆＃34;这是第一行if len(l) != len(set(l)):

并且b部分将列表拆分成可能的较短列表并检查它们是否是连续的。

def example (l, n):
    if len(l) != len(set(l)):  # part a
        return False
    for i in range(0, len(l)-n+1):  # part b
        if l[i:i+3] == sorted(l[i:i+3]):
            return True
    return False

l = [1, 3, 5, 2, 4, 6]
print example(l, 3)

Answer 7

这是一个非常简单易用的解决方案，无需使用任何导入：

range = range(10)
L = [1,3,5,2,4,6]
L = sorted(L, key = lambda L:L)
range[(L[0]):(len(L)+L[0])] == L

>>True

这适用于任何长度的数字列表并检测重复项。基本上，您正在创建列表可能存在的范围，编辑该范围以匹配列表的条件（长度，起始值）并进行快照比较。我想出了一个我正在编码的纸牌游戏，我需要在手中检测直道/跑步并且看起来效果非常好。

Answer 8

def solution(A):
    counter = [0]*len(A)
    limit = len(A)
    for element in A:
        if not 1 <= element <= limit:
            return False
        else:
            if counter[element-1] != 0:
                return False
            else:
                counter[element-1] = 1

    return True

Answer 9

此函数的输入是您的列表。如果重复数字，则此函数返回False。即使列表不是以1开头，下面的代码也可以工作。

def check_is_consecutive(l):
    """
    sorts the list and 
    checks if the elements in the list are consecutive
    This function does not handle any exceptions.
    returns true if the list contains consecutive numbers, else False
    """
    l = list(filter(None,l))
    l = sorted(l)
    if len(l) > 1:
        maximum = l[-1]
        minimum = l[0] - 1
        if minimum == 0:
            if sum(l) == (maximum * (maximum+1) /2): 
                return True
            else:
                return False
        else:
            if sum(l) == (maximum * (maximum+1) /2) - (minimum * (minimum+1) /2) : 
                return True
            else:
                return False
    else:
        return True

Answer 10

1。

l.sort（）

2。

for i in range(0,len(l)-1)))
   print(all((l[i+1]-l[i]==1)

Answer 11

列表必须排序！

lst = [9,10,11,12,13,14,15,16]

final = True if len( [ True for x in lst[:-1] for y in lst[1:] if x + 1 == y ] ) == len(lst[1:]) else False

我不知道这有多有效，但应该可以解决问题。

Answer 12

带有排序

在Python 3中，我使用以下简单解决方案：

def check(lst):
    lst = sorted(lst)
    if lst:
        return lst == list(range(lst[0], lst[-1] + 1))
    else:
        return True

请注意，对列表进行排序后，其最小值和最大值作为第一个（lst[0]）和最后一个（lst[-1]）元素免费提供。如果参数为空，我将返回True，但此决定是任意的。选择最适合您的用例的

。

在此解决方案中，我们首先对参数进行排序，然后将其与另一个我们知道是连续且没有重复的列表进行比较。

不进行排序

在其中一个答案中，OP进行了评论，询问是否可以在不对列表进行排序的情况下进行相同的操作。这很有趣，这是我的解决方案：

def check(lst):
    if lst:
        r = range(min(lst), max(lst) + 1) # *r* is our reference
        return (
            len(lst) == len(r)
            and all(map(lst.__contains__, r))
            # alternative: all(x in lst for x in r)
            # test if every element of the reference *r* is in *lst*
        )
    else:
        return True

在此解决方案中，我们建立参考范围r，它是int s的连续（因此是非重复）序列。这样，我们的测试就很简单：首先，我们将lst与参考进行比较，以确保元素数量正确（不多，这表示重复，也没有少，表示间隙）。然后我们检查引用中的每个元素是否也在lst中（这是all(map(lst.__contains__, r))的工作：在r上进行迭代并测试其所有元素是否都在{{1}中}。

Python：如何查看列表是否包含连续数字

12 个答案:

带有排序

不进行排序