Python 如何计算两个列表的所有交错？

我想创建一个函数，它接受两个列表，不保证列表长度相等，并返回两个列表之间的所有交错

输入：两个大小不必相等的列表

输出：两个列表之间保留原始列表顺序的所有可能交错

示例：allinterer（[1,2]，[3,4]）->[1,2,3,4]，[1,3,2,4]，[1,3,4,2]，[3,1,2,4]，[3,1,4,2]，[3,4,1,2]]

---

我不想要解决办法。我需要一个提示。

正如@airza所建议的那样，

itertools

模块是您的朋友

如果您想避免使用封装的魔法善，我的提示是使用递归

开始在脑海中播放生成列表的过程，当你注意到你又在做同样的事情时，尝试找到模式。例如：

从第一个列表中获取第一个元素

从另一个列表中选择第二个或第一个

你可以选择第三个，如果你没有选择第二个，或者从其他列表中选择另一个

好吧，这看起来有一些更大的逻辑我们没有使用。我只是在增加数字。当然，我可以找到一个基本情况，它在更改“第一个元素而不是命名更高的元素”时起作用

---

玩它。

提示：假设每个列表都有相同的元素（但列表之间不同），即一个列表是完全红色的（比如r），另一个是蓝色的（比如b）

输出的每个元素都包含r+b或它们，其中r为红色

似乎其他人已经为你破坏了它，即使你没有要求一个解决方案（但他们有一个很好的解释）

这里是我快速编写的代码

import itertools

def interleave(lst1, lst2):
    r,b = len(lst1), len(lst2)
    for s in itertools.combinations(xrange(0,r+b), r):
        lst = [0]*(r+b)
        tuple_idx,idx1,idx2 = 0,0,0
        for i in xrange(0, r+b):
            if tuple_idx < r and i == s[tuple_idx]:
                lst[i] = lst1[idx1]
                idx1 += 1
                tuple_idx += 1
            else: 
                lst[i] = lst2[idx2]
                idx2 += 1
        yield lst


def main():
    for s in interleave([1,2,3], ['a','b']):
        print s

if __name__ == "__main__":
    main()

导入itertools
def交织（lst1、lst2）：
r、 b=len（lst1），len（lst2）
对于itertools.组合中的s（X范围（0，r+b），r）：
lst=[0]*（r+b）
元组_idx，idx1，idx2=0,0,0
对于X范围内的i（0，r+b）：
如果tuple_idx

---

基本思想是将输出映射到（r+b）选择r组合。

您可以尝试更接近金属、更优雅的组合（在我看来）迭代不同的可能切片。基本上，逐步遍历并迭代标准切片操作的所有三个参数，删除添加到最终列表中的任何内容。如果您感兴趣，可以发布代码片段。

Itertools将无法处理此问题，需要对pe有一些了解气孔问题

考虑一下您的示例列表

A=[1,2] B=[3,4]

有四个孔（

len（A）+len（B）

）用于放置元件（销钉）

在Python中，可以将空插槽表示为

None

slots = [None]*(len(A) + len(B))

您可以将第二个列表中的元素（桩）放置到桩中的方式数量很简单，即您可以从指定的孔中选择插槽的方式数量

len（A）+len（B）

C

len（B）

=

4

C

2

=

itertools.组合（范围（0，len（len（A）+len（B））

这可以描述为

|   ||   ||   ||   |  Slots
|___||___||___||___|  Selected

  3    4              (0,1)
  3         4         (0,2)
  3              4    (0,3) 
       3    4         (1,2) 
       3         4    (1,3)
            3    4    (2,3)   

现在，对于每个插槽位置，用第二个列表中的元素（销钉）填充它

for splice in combinations(range(0,len(slots)),len(B)):
    it_B = iter(B)
    for s in splice:
        slots[s] = next(it_B)

完成后，只需使用第一个列表中的元素（PEG）填充剩余的空插槽

    it_A = iter(A)
    slots = [e if e else next(it_A) for e in slots]

在使用另一个插槽位置开始下一次迭代之前，请先将孔冲洗干净

    slots = [None]*(len(slots))

上述方法的Python实现

def slot_combinations(A,B):
    slots = [None]*(len(A) + len(B))
    for splice in combinations(range(0,len(slots)),len(B)):
        it_B = iter(B)
        for s in splice:
            slots[s] = next(it_B)
        it_A = iter(A)
        slots = [e if e else next(it_A) for e in slots]
        yield slots
        slots = [None]*(len(slots))

以及上述实施的O/p

list(slot_combinations(A,B))
[[3, 4, 1, 2], [3, 1, 4, 2], [3, 1, 2, 4], [1, 3, 4, 2], [1, 3, 2, 4], [1, 2, 3, 4]]

---

提示：导入itertools这是一个惊人的提示。我在python中的列表问题大部分是通过记住它是有限存在的来解决的。大多数没有被

itertools

解决的问题都是通过查看其文档中的配方来解决的。下面是一个比较懒惰的例子（如果子列表中插入了生成器）钉子和洞问题的解决方案：。啊，我们得到的不是提示，而是完整的实现。很好。很好的解释。你可以说我的问题是钉子和洞问题的一个实例，但没有提供实现。在我接受你的答案之前，你能校对一下吗（我认为解释中有一些拼写错误。它不应该是

=itertools.组合（范围（0，len（A）+len（B）），2）

？）并为“钉孔”问题提供前提吗？我尝试了谷歌搜索，但只找到了“方钉孔和圆孔”“问题或类似的问题。如果你提供了一个好的前提，我甚至会建议你删掉实现部分，但这是你的选择。

list(slot_combinations(A,B))
[[3, 4, 1, 2], [3, 1, 4, 2], [3, 1, 2, 4], [1, 3, 4, 2], [1, 3, 2, 4], [1, 2, 3, 4]]