Question

假设我有一个任意数量的iterables，可以假设它们都被排序，并且包含所有相同类型的元素（整数，为了便于说明）。

a = (1, 2, 3, 4, 5)
b = (2, 4, 5)
c = (1, 2, 3, 5)

我想写一个生成函数，产生以下内容：

(1, None, 1)
(2, 2, 2)
(3, None, 3)
(4, 4, None)
(5, 5, 5)

换句话说，逐步产生带有间隙的排序元组，其中元素从输入迭代中缺失。

Answer 1

我们首先需要heapq.merge的变体，它也会产生索引。您可以通过复制粘贴heapq.merge并将每个yield v替换为yield itnum, v来实现。（为了便于阅读，我在答案中省略了那部分。）

现在我们可以做到：

from collections import deque, OrderedDict

def f(*iterables):
    pending = OrderedDict()
    for i, v in merge(iterables):
        if (not pending) or pending.keys()[-1] < v:
            # a new greatest value
            pending[v] = [None] * len(iterables)
        pending[v][i] = v
        # yield all values smaller than v
        while len(pending) > 1 and pending.keys()[0] < v:
            yield pending.pop(pending.keys()[0])
    # yield remaining
    while pending:
        yield pending.pop(pending.keys()[0])

print list(f((1,2,3,4,5), (2,4,5), (1,2,3,5)))
=> [[1, None, 1], [2, 2, 2], [3, None, 3], [4, 4, None], [5, 5, 5]]

Answer 2

我对此的看法，只使用迭代器，而不是堆：

a = (1, 2, 4, 5)
b = (2, 5)
c = (1, 2, 6)
d = (1,)
inputs = [iter(x) for x in (a, b, c, d)]

def minwithreplacement(currents, inputs, minitem, done):
    for i in xrange(len(currents)):
        if currents[i] == minitem:
            try:
                currents[i] = inputs[i].next()
            except StopIteration:
                currents[i] = None
                done[0] += 1
            yield minitem
        else:
            yield None

def dothing(inputs):
    currents = [it.next() for it in inputs]
    done = [0]
    while done[0] != len(currents):
        yield minwithreplacement(currents, inputs, min(x for x in currents if x), done)

print [list(x) for x in dothing(inputs)] #Consuming iterators for display purposes
>>>[[1, None, 1, 1], [2, 2, 2, None], [4, None, None, None], [5, 5, None, None], [None, None, 6, None]]

生成器从压缩的iterables中产生间隙元组

2 个答案: