Question

我有一个包含数据的列表：

[1, 2, 3, 4, 7, 8, 10, 11, 12, 13, 14]

我想打印出连续整数的范围：

1-4, 7-8, 10-14

是否有内置/快速/有效的方法？

Answer 1

来自the docs：

>>> from itertools import groupby
>>> from operator import itemgetter
>>> data = [ 1, 4,5,6, 10, 15,16,17,18, 22, 25,26,27,28]
>>> for k, g in groupby(enumerate(data), lambda (i, x): i-x):
...     print map(itemgetter(1), g)
...
[1]
[4, 5, 6]
[10]
[15, 16, 17, 18]
[22]
[25, 26, 27, 28]

你可以很容易地调整它以获得一组打印范围。

Answer 2

内置：不，据我所知。

你必须运行数组。首先将第一个值放入一个变量并打印出来，然后只要你继续点击下一个数字就什么都不做，只记得另一个变量中的最后一个数字。如果下一个号码不在一行，请检查记住的最后一个号码与第一个号码。如果它是相同的，什么也不做。如果不同，请打印“ - ”和最后一个数字。然后将当前值放在第一个变量中并重新开始。在数组的末尾，您运行相同的例程，就好像您已经超出了一个数字。

我当然可以编写代码，但我不想破坏你的作业： - ）

Answer 3

这将完全按照您的指定打印：

>>> nums = [1, 2, 3, 4, 7, 8, 10, 11, 12, 13, 14]
>>> ranges = sum((list(t) for t in zip(nums, nums[1:]) if t[0]+1 != t[1]), [])
>>> iranges = iter(nums[0:1] + ranges + nums[-1:])
>>> print ', '.join([str(n) + '-' + str(next(iranges)) for n in iranges])
1-4, 7-8, 10-14

如果列表有任何单个数字范围，它们将显示为n-n：

>>> nums = [1, 2, 3, 4, 5, 7, 8, 9, 12, 15, 16, 17, 18]
>>> ranges = sum((list(t) for t in zip(nums, nums[1:]) if t[0]+1 != t[1]), [])
>>> iranges = iter(nums[0:1] + ranges + nums[-1:])
>>> print ', '.join([str(n) + '-' + str(next(iranges)) for n in iranges])
1-5, 7-9, 12-12, 15-18

Answer 4

一个没有额外导入的简短解决方案。它接受任何可迭代的，排序未排序的输入，并删除重复的项目：

def ranges(nums):
    nums = sorted(set(nums))
    gaps = [[s, e] for s, e in zip(nums, nums[1:]) if s+1 < e]
    edges = iter(nums[:1] + sum(gaps, []) + nums[-1:])
    return list(zip(edges, edges))

示例：

>>> ranges([2, 3, 4, 7, 8, 9, 15])
[(2, 4), (7, 9), (15, 15)]

>>> ranges([-1, 0, 1, 2, 3, 12, 13, 15, 100])
[(-1, 3), (12, 13), (15, 15), (100, 100)]

>>> ranges(range(100))
[(0, 99)]

>>> ranges([0])
[(0, 0)]

>>> ranges([])
[]

这与@ dansalmo的solution相同，我发现它很神奇，虽然有点难以阅读和应用（因为它没有作为函数提供）。

请注意，可以轻松修改它以吐出“传统”开放范围[start, end)，例如改变return语句：

    return [(s, e+1) for s, e in zip(edges, edges)]

Answer 5

我遇到了类似的问题，并使用以下内容作为排序列表。它输出一个字典，其中包含字典中列出的值范围。键将每个连续数字的行分开，并且也是数字之间的非顺序项的运行总数。

您的列表为我提供了{0: [1, 4], 1: [7, 8], 2: [10, 14]}

的输出

def series_dictf(index_list):
    from collections import defaultdict    
    series_dict = defaultdict(list)
    sequence_dict = dict()

    list_len = len(index_list)
    series_interrupts = 0    

    for i in range(list_len):
        if i == (list_len - 1):
                break

        position_a = index_list[i]
        position_b = index_list[i + 1]

        if position_b == (position_a + 1):
            sequence_dict[position_a] = (series_interrupts)
            sequence_dict[position_b] = (series_interrupts)

        if position_b != (position_a + 1):
            series_interrupts += 1  

    for position, series in sequence_dict.items():
        series_dict[series].append(position)
    for series, position in series_dict.items():
        series_dict[series] = [position[0], position[-1]]

    return series_dict

Answer 6

使用set操作，可以执行以下算法

<script>
        function addEvent(obj, evt, fn) {
            if (obj.addEventListener) {
                obj.addEventListener(evt, fn, false);
            }
            else if (obj.attachEvent) {
                obj.attachEvent("on" + evt, fn);
            }
        }
        addEvent(window, "load", function (e) {
            addEvent(document, "mouseleave", function (e) {
                e = e ? e : window.event;
                var from = e.relatedTarget || e.toElement;
                if (!from || from.nodeName == "HTML") {

                    //.... do_this
                }
            });
        });
    </script>

以上列表的输出＆＃34; a＆＃34;
1-4
6-8
14-15
21

Answer 7

这是另一个不使用任何模块的基本解决方案，这对面试很有帮助，通常在他们不使用任何模块的情况下进行的采访中：

#!/usr/bin/python

def split_list(n):
    """will return the list index"""
    return [(x+1) for x,y in zip(n, n[1:]) if y-x != 1]

def get_sub_list(my_list):
    """will split the list base on the index"""
    my_index = split_list(my_list)
    output = list()
    prev = 0
    for index in my_index:
        new_list = [ x for x in my_list[prev:] if x < index]
        output.append(new_list)
        prev += len(new_list)
    output.append([ x for x in my_list[prev:]])
    return output

my_list = [1, 3, 4, 7, 8, 10, 11, 13, 14]
print get_sub_list(my_list)

输出：

[[1], [3, 4], [7, 8], [10, 11], [13, 14]]

Answer 8

您可以使用具有名为Counter的类的集合库。如果试图在任何可迭代的

中轮询不同的元素，Counter可以派上用场

from collections import Counter
data = [ 1, 4,5,6, 10, 15,16,17,18, 22, 25,26,27,28]
cnt=Counter(data)
print(cnt)

这个输出看起来像

Counter({1: 1, 4: 1, 5: 1, 6: 1, 10: 1, 15: 1, 16: 1, 17: 1, 18: 1, 22: 1, 25: 1, 26: 1, 27: 1, 28: 1})

与任何其他字典一样，可以轮询键值

检测列表中的连续整数

8 个答案: