在列表中查找不断增加的数字组
Posted
技术标签:
【中文标题】在列表中查找不断增加的数字组【英文标题】：Finding groups of increasing numbers in a list 【发布时间】：2016-01-28 21:26:58 【问题描述】：目标是在给定整数列表的情况下找到递增/单调数组。结果组中的每个项目必须比前一个项目增加 +1
给定一个输入：
x = [7, 8, 9, 10, 6, 0, 1, 2, 3, 4, 5]
我需要找到数量不断增加的组并实现：
increasing_numbers = [(7,8,9,10), (0,1,2,3,4,5)]
最后还有越来越多的数字：
len(list(chain(*increasing_numbers)))
还有组的 len：
increasing_num_groups_length = [len(i) for i in increasing_numbers]
我尝试了以下方法来获取不断增加的数字：
>>> from itertools import tee, chain
>>> def pairwise(iterable):
... a, b = tee(iterable)
... next(b, None)
... return zip(a, b)
...
>>> x = [8, 9, 10, 11, 7, 1, 2, 3, 4, 5, 6]
>>> set(list(chain(*[(i,j) for i,j in pairwise(x) if j-1==i])))
set([1, 2, 3, 4, 5, 6, 8, 9, 10, 11])
>>> len(set(list(chain(*[(i,j) for i,j in pairwise(x) if j-1==i]))))
10
但我无法保持顺序和数量不断增加的组。
如何实现increasing_numbers 整数元组组和increasing_num_groups_length？
另外，是否有此类/类似问题的名称？
已编辑
我想出了这个解决方案，但它非常冗长，我确信有一种更简单的方法可以实现 increasing_numbers 输出：
>>> from itertools import tee, chain
>>> def pairwise(iterable):
... a, b = tee(iterable)
... next(b, None)
... return zip(a, b)
...
>>> x = [8, 9, 10, 11, 7, 1, 2, 3, 4, 5, 6]
>>> boundary = iter([0] + [i+1 for i, (j,k) in enumerate(pairwise(x)) if j+1!=k] + [len(x)])
>>> [tuple(x[i:next(boundary)]) for i in boundary]
[(8, 9, 10, 11), (1, 2, 3, 4, 5, 6)]
有没有更pythonic/更简洁的方法来做到这一点？
另一个输入/输出示例：
[输入]：
[17, 17, 19, 20, 21, 22, 0, 1, 2, 2, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14、14、14、28、29、30、31、32、33、34、35、36、40]
[出]：
[(19, 20, 21, 22), (0, 1, 2), (4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14), (28, 29, 30, 31, 32, 33, 34, 35, 36)]
【问题讨论】：
它会调用您的问题：查找数据单调且递增的区间。它实际上就像找到数据不增加的地方一样简单，并将其用作您的组的边界（假设数据永远不会减少，但两者似乎都是如此您的描述和您的意见）。 我的解决方案看起来像一些怪物 perl 脚本 =( 有没有人知道这个的 pythonic 解决方案？顺便说一句，这不是家庭作业，只是试图让算法的一部分正确。它需要这个“单调”或递增序列计数。 当pythonic变得晦涩难懂时，我通常会选择一个简单的for循环。 @alvas。您的输出似乎是错误的，因为第二个序列开始于0, 1, 2, 2, ...。
@alvas。这开始变得很有趣：现在你错过了0, 1, 2 作为第二个序列。也许您应该使用其中一个答案来检查您的问题是否正确；-)
【参考方案1】：
def igroups(L):
R=[[]]
[R[-1].append(L[i]) for i in range(len(L)) if (L[i-1]+1==L[i] if L[i-1]+1==L[i] else R.append([L[i]]))]
return [P for P in R if len(P)>1]
tests=[[],
[0, 0, 0],
[7, 8, 9, 10, 6, 0, 1, 2, 3, 4, 5],
[8, 9, 10, 11, 7, 1, 2, 3, 4, 5, 6],
[9, 1, 2, 3, 1, 1, 2, 3, 5],
[4,3,2,1,1,2,3,3,4,3],
[1, 4, 3],
[1],
[1,2],
[2,1]
]
for L in tests:
print(L)
print(igroups(L))
print("-"*10)
输出以下内容：
[]
[]
----------
[0, 0, 0]
[]
----------
[7, 8, 9, 10, 6, 0, 1, 2, 3, 4, 5]
[[7, 8, 9, 10], [0, 1, 2, 3, 4, 5]]
----------
[8, 9, 10, 11, 7, 1, 2, 3, 4, 5, 6]
[[8, 9, 10, 11], [1, 2, 3, 4, 5, 6]]
----------
[9, 1, 2, 3, 1, 1, 2, 3, 5]
[[1, 2, 3], [1, 2, 3]]
----------
[4, 3, 2, 1, 1, 2, 3, 3, 4, 3]
[[1, 2, 3], [3, 4]]
----------
[1, 4, 3]
[]
----------
[1]
[]
----------
[1, 2]
[[1, 2]]
----------
[2, 1]
[]
----------
编辑
我第一次尝试使用itertools.groupby 失败了，对此感到抱歉。
【讨论】：
Lolz，可以理解但非常神秘。愿意解释一下答案吗？ ;P 正如 Python 库文档所解释的那样，groupby 每次 lambda 函数的值发生变化时都会生成一个新组（从 True 表示序列增加到 False 表示序列停止增加）。
@P.Ortiz。您当前的代码看起来像已损坏，因为它输出：[[7, 8, 9], [10, 6], [0, 1, 2, 3, 4]]。
我的错误和道歉；我完全问错了问题。【参考方案2】：
编辑：
这是一个代码高尔夫解决方案（142 个字符）：
def f(x):s=[0]+[i for i in range(1,len(x)) if x[i]!=x[i-1]+1]+[len(x)];return [x[j:k] for j,k in [s[i:i+2] for i in range(len(s)-1)] if k-j>1]
扩展版：
def igroups(x):
s = [0] + [i for i in range(1, len(x)) if x[i] != x[i-1] + 1] + [len(x)]
return [x[j:k] for j, k in [s[i:i+2] for i in range(len(s)-1)] if k - j > 1]
评论版本：
def igroups(x):
# find the boundaries where numbers are not consecutive
boundaries = [i for i in range(1, len(x)) if x[i] != x[i-1] + 1]
# add the start and end boundaries
boundaries = [0] + boundaries + [len(x)]
# take the boundaries as pairwise slices
slices = [boundaries[i:i + 2] for i in range(len(boundaries) - 1)]
# extract all sequences with length greater than one
return [x[start:end] for start, end in slices if end - start > 1]
原解决方案：
不确定这算作“pythonic”还是“不太冗长”：
def igroups(iterable):
items = iter(iterable)
a, b = None, next(items, None)
result = [b]
while b is not None:
a, b = b, next(items, None)
if b is not None and a + 1 == b:
result.append(b)
else:
if len(result) > 1:
yield tuple(result)
result = [b]
print(list(igroups([])))
print(list(igroups([0, 0, 0])))
print(list(igroups([7, 8, 9, 10, 6, 0, 1, 2, 3, 4, 5])))
print(list(igroups([8, 9, 10, 11, 7, 1, 2, 3, 4, 5, 6])))
print(list(igroups([9, 1, 2, 3, 1, 1, 2, 3, 5])))
输出：
[]
[]
[(7, 8, 9, 10), (0, 1, 2, 3, 4, 5)]
[(8, 9, 10, 11), (1, 2, 3, 4, 5, 6)]
[(1, 2, 3), (1, 2, 3)]
【讨论】：
感谢您的回答，它看起来确实更“可读”。但也许有更简单的方法。这并不像投反对票的人想的那么简单，对吧？ @ekhumoro：最后输出，终极5不见了，不是吗？ @P.Ortiz。不：我从 OP 自己的解决方案 (if j+1!=k) 中假设他们只想要没有间隙的序列（即总是加一）。但是，如果不是这种情况，则可以将测试更改为a < b。
@alvas。我不完全确定您的问题为什么会受到如此多的反对。可能是因为需求没有很好地定义，并且您没有说明在尝试找到解决方案时遇到了哪些具体问题。什么确切地会算作“更简单的方式”？我希望你不只是指“更短”，因为这对 SO 来说是题外话。如果您想要更短，请在 codegolf 上询问。
肯定不会更短。就像更容易理解并且希望更pythonic一样，可能与您所做的类似。问题只是将增加的数字分组到列表中 =)【参考方案3】：
使用itertools.groupby，将整数列表L 划分到相邻项的子列表中并从L 增加连续项的问题可以使用单线来完成。不过我不知道它是如何被认为是pythonic ;)
下面是一些简单测试的代码：
[编辑：现在子序列增加了1，我第一次错过了这一点。]
from itertools import groupby
def f(i):
return L[i-1]+1==L[i]
def igroups(L):
return [[L[I[0]-1]]+[L[i] for i in I] for I in [I for (v,I) in [(k,[i for i in list(g)]) for (k, g) in groupby(range(1, len(L)), f)] if v]]
输出：
tests=[
[0, 0, 0, 0],
[7, 8, 9, 10, 6, 0, 1, 2, 3, 4, 5],
[8, 9, 10, 11, 7, 1, 2, 3, 4, 5, 6],
[9, 1, 2, 3, 1, 1, 2, 3, 5],
[4,3,2,1,1,2,3,3,4,3],
[1, 4, 3],
[1],
[1,2, 2],
[2,1],
[0, 0, 0, 0, 2, 5, 5, 8],
]
for L in tests:
print(L)
print(igroups(L))
print('-'*10)
[0, 0, 0, 0]
[]
----------
[7, 8, 9, 10, 6, 0, 1, 2, 3, 4, 5]
[[7, 8, 9, 10], [0, 1, 2, 3, 4, 5]]
----------
[8, 9, 10, 11, 7, 1, 2, 3, 4, 5, 6]
[[8, 9, 10, 11], [1, 2, 3, 4, 5, 6]]
----------
[9, 1, 2, 3, 1, 1, 2, 3, 5]
[[1, 2, 3], [1, 2, 3]]
----------
[4, 3, 2, 1, 1, 2, 3, 3, 4, 3]
[[1, 2, 3], [3, 4]]
----------
[1, 4, 3]
[]
----------
[1]
[]
----------
[1, 2, 2]
[[1, 2]]
----------
[2, 1]
[]
----------
[0, 0, 0, 0, 2, 5, 5, 8]
[]
----------
一些解释。如果你“展开”代码，逻辑就更明显了：
from itertools import groupby
def f(i):
return L[i]==L[i-1]+1
def igroups(L):
monotonic_states = [(k,list(g)) for (k, g) in groupby(range(1, len(L)), f)]
increasing_items_indices = [I for (v,I) in monotonic_states if v]
print("\nincreasing_items_indices ->", increasing_items_indices, '\n')
full_increasing_items= [[L[I[0]-1]]+[L[i] for i in I] for I in increasing_items_indices]
return full_increasing_items
L= [2, 8, 4, 5, 6, 7, 8, 5, 9, 10, 11, 12, 25, 26, 27, 42, 41]
print(L)
print(igroups(L))
输出：
[2, 8, 4, 5, 6, 7, 8, 5, 9, 10, 11, 12, 25, 26, 27, 42, 41]
increasing_items_indices -> [[3, 4, 5, 6], [9, 10, 11], [13, 14]]
[[4, 5, 6, 7, 8], [9, 10, 11, 12], [25, 26, 27]]
我们需要一个关键函数f，它将一个项目与给定列表中的前一个项目进行比较。现在，重要的一点是 groupby 函数和键函数 f 提供了一个元组 (k, S) 其中 S 表示初始列表中的 相邻 索引，f 的状态是常数，状态由k 的值给出：如果k 是True，则S 表示增加（1）项索引，否则不增加项索引。 （实际上，如上例所示，列表 S 是不完整的，缺少第一项）。
我还对一百万个项目列表进行了一些随机测试：igroups 函数总是返回正确的响应，但比简单实现慢 4 倍！更简单更容易更快;)
感谢 alvas 的提问，这给了我很多乐趣！
【讨论】：
很好的答案！感谢您展开列表理解并对其进行解释。 是否有理由使用L[i]>L[i-1] 而不是L[i] == L[i]+1？
@alvas：我猜你是在说key函数的定义吧？但是L[i] == L[i]+1 怎么可能呢？
啊，我明白你在做什么，你也在保持增加但不是 +1 的序列！酷！！！
@P.Ortiz。 OP 在其他 cmets 中说过，序列应该只增加 1。所以也许他们的意思是L[i] == L[i-1]+1？ （PS：什么是“幼稚”的实现？）【参考方案4】：
使用 itertools 和 numpy 的几种不同方式：
from itertools import groupby, tee, cycle
x = [17, 17, 19, 20, 21, 22, 0, 1, 2, 2, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 14, 14, 28, 29, 30, 31, 32, 33, 34, 35,
36, 1, 2, 3, 4,34,54]
def sequences(l):
x2 = cycle(l)
next(x2)
grps = groupby(l, key=lambda j: j + 1 == next(x2))
for k, v in grps:
if k:
yield tuple(v) + (next((next(grps)[1])),)
print(list(sequences(x)))
[(19, 20, 21, 22), (0, 1, 2), (4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14), (28, 29, 30, 31, 32, 33, 34, 35, 36), (1, 2, 3, 4)]
或者使用python3和yield from：
def sequences(l):
x2 = cycle(l)
next(x2)
grps = groupby(l, key=lambda j: j + 1 == next(x2))
yield from (tuple(v) + (next((next(grps)[1])),) for k,v in grps if k)
print(list(sequences(x)))
使用我的答案here 与 numpy.split 的变体：
out = [tuple(arr) for arr in np.split(x, np.where(np.diff(x) != 1)[0] + 1) if arr.size > 1]
print(out)
[(19, 20, 21, 22), (0, 1, 2), (4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14), (28, 29, 30, 31, 32, 33, 34, 35, 36), (1, 2, 3, 4)]
和 ekhumoro 的回答类似：
def sequences(x):
it = iter(x)
prev, temp = next(it), []
while prev is not None:
start = next(it, None)
if prev + 1 == start:
temp.append(prev)
elif temp:
yield tuple(temp + [prev])
temp = []
prev = start
获取长度和元组：
def sequences(l):
x2 = cycle(l)
next(x2)
grps = groupby(l, key=lambda j: j + 1 == next(x2))
for k, v in grps:
if k:
t = tuple(v) + (next(next(grps)[1]),)
yield t, len(t)
def sequences(l):
x2 = cycle(l)
next(x2)
grps = groupby(l, lambda j: j + 1 == next(x2))
yield from ((t, len(t)) for t in (tuple(v) + (next(next(grps)[1]),)
for k, v in grps if k))
def sequences(x):
it = iter(x)
prev, temp = next(it), []
while prev is not None:
start = next(it, None)
if prev + 1 == start:
temp.append(prev)
elif temp:
yield tuple(temp + [prev]), len(temp) + 1
temp = []
prev = start
这三个的输出都是一样的：
[((19, 20, 21, 22), 4), ((0, 1, 2), 3), ((4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14), 11)
, ((28, 29, 30, 31, 32, 33, 34, 35, 36), 9), ((1, 2, 3, 4), 4)]
【讨论】：
numpy 解决方案看起来很有趣。你能帮忙解释一下numpy方法吗？np.diff 和 np.where 和 np.split 有点神秘；P
@alvas，我添加了一个指向我的旧答案的链接，逻辑基本相同
谢谢！！这很有帮助 =)
@alvas，看看编辑，看看我们是否在同一页面上
完美！！谢谢帕德莱克！【参考方案5】：
如果两个连续的数字加一，我会在这些数字中形成 tuples 的 list (group)。
当不增加且list (group) 非空时，我将其解压缩并再次zip 以重建被zip 破坏的序列对。我使用set 理解来消除重复数字。
def extract_increasing_groups(seq):
seq = tuple(seq)
def is_increasing(a,b):
return a + 1 == b
def unzip(seq):
return tuple(sorted( y for x in zip(*seq) for y in x))
group = []
for a,b in zip(seq[:-1],seq[1:]):
if is_increasing(a,b):
group.append((a,b))
elif group:
yield unzip(group)
group = []
if group:
yield unzip(group)
if __name__ == '__main__':
x = [17, 17, 19, 20, 21, 22, 0, 1, 2, 2, 4, 5, 6, 7, 8, 9, 10, 11, 12,
13, 14, 14, 14, 28, 29, 30, 31, 32, 33, 34, 35, 36, 40]
for group in extract_increasing_groups(x):
print(group)
使用集合更简单；
from collections import namedtuple
from itertools import islice, tee
def extract_increasing_groups(iterable):
iter1, iter2 = tee(iterable)
iter2 = islice(iter2,1,None)
is_increasing = lambda a,b: a + 1 == b
Igroup = namedtuple('Igroup','group, len')
group = set()
for pair in zip(iter1, iter2):
if is_increasing(*pair):
group.update(pair)
elif group:
yield Igroup(tuple(sorted(group)),len(group))
group = set()
if group:
yield Igroup(tuple(sorted(group)), len(group))
if __name__ == '__main__':
x = [17, 17, 19, 20, 21, 22, 0, 1, 2, 2, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 14, 14, 28, 29, 30, 31, 32, 33, 34, 35, 36, 40]
total = 0
for group in extract_increasing_groups(x):
total += group.len
print('Group: \nLength: '.format(group.group, group.len))
print('Total: '.format(total))
【讨论】：
【参考方案6】：一个（非常）简单的实现：
x = [7, 8, 9, 10, 6, 0, 1, 2, 3, 4, 5]
result = []
current = x[0]
temp = []
for i in xrange(1, len(x)):
if (x[i] - current == 1):
temp.append( x[i] )
else:
if (len(temp) > 1):
result.append(temp)
temp = [ x[i] ]
current = x[i]
result.append(temp)
你会得到[ [7, 8, 9, 10], [0, 1, 2, 3, 4, 5] ]。从那里，您可以通过[ len(x) for x in result ] 和数字总数sum( len(x) for x in result) 获得递增数字的数量。
【讨论】：
【参考方案7】：我认为这行得通。这并不花哨，但很简单。它构造了一个开始列表sl 和一个结束列表el，它们的长度应该始终相同，然后使用它们来索引x：
def igroups(x):
sl = [i for i in range(len(x)-1)
if (x == 0 or x[i] != x[i-1]+1) and x[i+1] == x[i]+1]
el = [i for i in range(1, len(x))
if x[i] == x[i-1]+1 and (i == len(x)-1 or x[i+1] != x[i]+1)]
return [x[sl[i]:el[i]+1] for i in range(len(sl))]
【讨论】：
【参考方案8】：我认为最可维护的解决方案是让它变得简单：
def group_by(l):
res = [[l[0]]]
for i in range(1, len(l)):
if l[i-1] < l[i]:
res[-1].append(l[i])
else:
res.append([l[i]])
return res
这个方案没有过滤掉单个元素序列，但是很容易实现。此外，这具有 O(n) 复杂度。如果你愿意，你也可以把它变成一个生成器。
我所说的可维护性是指不是 300 个字符的单行代码，带有一些复杂的表达式。那么也许你会想要使用 Perl :)。至少一年后你会知道该函数的行为方式。
>>> x = [7, 8, 9, 10, 6, 0, 1, 2, 3, 4, 5]
>>> print(group_by(x))
[[7, 8, 9, 10], [6], [0, 1, 2, 3, 4, 5]]
【讨论】：
【参考方案9】：迟到的答案，但一个简单的实现，泛化为一个谓词，因此它不一定是增加的数字，但可以很容易地是两个数字之间的任何关系。
def group_by(lst, predicate):
result = [[lst[0]]]
for i, x in enumerate(lst[1:], start=1):
if not predicate(lst[i - 1], x):
result.append([x])
else:
result[-1].append(x)
return list(filter(lambda lst: len(lst) > 1, result))
对此进行测试：
>>> group_by([1,2,3,4, 7, 1, 0, 2], lambda x, y: x < y)
[[1, 2, 3, 4, 7], [0, 2]]
>>> group_by([1,2,3,4, 7, 1, 0, 2], lambda x, y: x > y)
[[7, 1, 0]]
>>> group_by([1,2,3,4, 7, 1, 0, 0, 2], lambda x, y: x < y)
[[1, 2, 3, 4, 7], [0, 2]]
>>> group_by([1,2,3,4, 7, 1, 0, 0, 2], lambda x, y: x > y)
[[7, 1, 0]]
>>> group_by([1,2,3,4, 7, 1, 0, 0, 2], lambda x, y: x >= y)
[[7, 1, 0, 0]]
>>>
现在我们可以轻松地对此进行专门化：
>>> def ascending_groups(lst):
... return group_by(lst, lambda x, y: x < y)
...
>>> ascending_groups([1,2,3,4, 7, 1, 0, 0, 2])
[[1, 2, 3, 4, 7], [0, 2]]
>>>
【讨论】：
以上是关于在列表中查找不断增加的数字组的主要内容，如果未能解决你的问题，请参考以下文章