如何根据一个布尔字段在Python中保持顺序创建元组列表的所有排列

Question

假设我有一个像这样的元组列表的输入：

[('a', True),
 ('b', False),
 ('c', True),
 ('d', False)] 

每个以True 作为第二个参数的元组都被认为是可选的。

• 列表中元组的数量是任意的
• 第一个值的值是任意的，必须保留

现在我想通过以下方式排列这个结构：

• 输出应该是一个元组列表
• 每个元组列表都是唯一的
• 列表区分是否存在的可选元组
• False 的元组不会改变（消失）
• 列表中元组的顺序不会改变
• 元组的顺序没有改变
• 元组列表可以按任意顺序排列

因此，上述示例的输出应如下所示：

[[('a', True),
  ('b', False),
  ('c', True),
  ('d', False)],

 [('b', False),
  ('c', True),
  ('d', False)],

 [('a', True),
  ('b', False),
  ('d', False)],

 [('b', False),
  ('d', False)]]

任何想法如何以优雅的方式解决这个问题？我尝试了递归，但我无法成功。

Answer 1

我不确定是否有特别优雅的方式。从概念上讲，您需要计算可选元素的幂集，但以满足您要求的方式将其与非可选元素合并。这是一种方法：

import itertools
a = [('a', True), ('b', False), ('c', True), ('d', False)]
optional_count = sum(optional for x, optional in a)
for include in itertools.product([True, False], repeat=optional_count):
    include_iter = iter(include)
    print([
        (x, optional)
        for x, optional in a
        if not optional or next(include_iter)
    ])

打印

[('a', True), ('b', False), ('c', True), ('d', False)]
[('a', True), ('b', False), ('d', False)]
[('b', False), ('c', True), ('d', False)]
[('b', False), ('d', False)]

循环遍历所有元组，指示是否包含可选元素：

True, True
True, False
False, True
False, False

打印语句中的列表推导包括所有非可选元素，对于可选元素，请查看来自include 的下一个可用元素。

Answer 2

您可以通过制作目前已做出选择列表的副本并将新值附加到副本中然后将其与迄今为止做出的选择列表合并来做出选择。

很抱歉，这个可怕的解释，但我现在想不出更好的办法。随意编辑，如果你能想出更好的东西。否则我希望下面的图表和代码能更好地解释我的解决方案。

                                        []
                    -------------------------------------------
                   []                                        [0]
       ----------------------------                ---------------------------
       []                       [1]                [0]                  [0, 1]
       ...                      ...                ...                  ...

基本思想是迭代所有项目，克隆所有部分解决方案并将项目附加到克隆的解决方案。

def choose(arr):
    res = [[]]

    for t in arr:
        if t[1]:
            # make a copy of all found solutions
            clone = [list(c) for c in res]

            # append the new value to the original solutions
            for l in res:
                l.append(t)

            # merge solution-list with the list of copies
            res += clone
        else:
            # non-optional element => just add the element to all solutions
            for l in res:
                l.append(t)

    return res

输出：

print('\n'.join(str(l) for l in choose([('a', True), ('b', False), ('c', True), ('d', False)])

[('a', True), ('b', False), ('c', True), ('d', False)]
[('b', False), ('c', True), ('d', False)]
[('a', True), ('b', False), ('d', False)]
[('b', False), ('d', False)]

Answer 3

其实我刚刚想到了一个不错的递归解决方案：

def choices(a):
    if not a:
        yield []
        return
    head, *tail = a
    if head[1]:
        yield from choices(tail)
    for tail_choice in choices(tail):
        yield [head] + tail_choice

这会在所有元组列表上创建一个惰性生成器：

>>> list(choices(a))
[[('b', False), ('d', False)],
 [('b', False), ('c', True), ('d', False)],
 [('a', True), ('b', False), ('d', False)],
 [('a', True), ('b', False), ('c', True), ('d', False)]]