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

我想测试一个列表是否包含连续的整数，并且没有重复的数字。 例如，如果我有

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

它应该是真的

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

---

有更好的方法吗？

对于整个列表，它应该尽可能简单

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

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

请注意，在Python2中，您可以简单地使用以下命令，因为

range

返回了一个

list

对象。在3.x及更高版本中，函数已更改为返回

范围

对象，因此在与

排序（l）

进行比较之前，需要显式转换为

列表

要检查

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])

---

第一个代码删除重复项，但保持顺序：

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]

下一组是确定哪些是有序的，取自：

l

输出为：

1-2,4-6,3

---

您可以根据您的输出自定义函数。

一旦验证列表没有重复项，只需计算

min（l）

和

max（l）

之间的整数之和：

def检查（l）：
总数=0
最小值=浮动（“+inf”）
最大值=浮动（'-inf'）
seen=set（）
对于l中的n：
如果看到n：
返回错误
见。添加（n）
如果n<最小值：
最小值=n
如果n>最大值：
最大值=n
总数+=n
如果2*总计！=最大值*（最大值+1）-最小值*（最小值-1）：
返回错误
返回真值

我将您的查询分为两部分A部分“列表最多包含n个连续数字”如果len（l）！=len（set（l））：

第二部分，将列表拆分为可能较短的列表，并检查它们是否连续

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)

---

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

sum of consecutive n numbers 1...n = n * (n+1) /2 


  def check_is_consecutive(l):
        maximum = max(l)
        if sum(l) == maximum * (maximum+1) /2 : 
             return True
        return False

---

我们测试这两个条件，首先通过找到排序列表的迭代差

np.diff（sorted（l））

我们可以测试是否存在

n

连续整数。最后，我们测试

值\u counts（）

是否全部为1，表示没有重复。

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

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

这适用于任何长度的数字列表，并检测重复项。 基本上，您正在创建列表可能所在的范围，编辑该范围以匹配列表的标准（长度、起始值）并进行快照比较。我为一款我正在编写的纸牌游戏想出了这个方法，我需要检测手上的直杆/跑动，它似乎工作得很好

def溶液（A）：
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

计数器=[0]*len（A）
极限=len（A）
对于A中的元素：
如果不是1则此函数的输入是您的列表。如果数字重复，则此函数返回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

一,

l、 排序（）

二,

列表必须排序

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

我不知道这有多高效，但它应该能起到作用。
有了排序
在Python 3中，我使用以下简单的解决方案：

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

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

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

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

不分类
在其中一个答案中，OP评论道，如果不对列表进行排序，是否也可以这样做。这很有趣，这是我的解决方案：

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

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.\uuu包含\uuuu，r））
所做的：它迭代
r
并测试其所有元素是否都在
lts
中）.
在您的示例中答案应该是什么？我不明白为什么您的测试用例应该返回
True
，5和2不是连续的整数？它们是非负的还是严格的正的？在R中，它将是
any（diff（sort（x））==1）和all（table（x）==1）
，但我还不懂Python，所以我想看看它是如何实现的。我在尽可能地翻译这两个数字，如果数字是连续的，就不会有重复的数字。所以第二个条件是多余的。检查
[1,2,2,3]
时，所需的输出是什么？如果答案为
True
是否有其他不使用排序的方法？这两种情况下的测试结果如何？我想你需要重读这个问题。首先考虑你的“解决方案”不返回逻辑。@ WnnMAW这个解决方案需要稍稍调整一下。测试将检查所有数字是否连续。OP正在检查“n”是否连续。然后，您必须为第二个条件添加一个检查，“数字不重复”。对于整个列表，它是否应该是
排序的（l）=列表（范围（最小（l），最大（l）+1））
？@Zuabi，是的，对于Python 3.x和更高版本，您需要显式地进行列表转换。我已经为
[1,1,4,4,5]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

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

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