相关疑难解决方法(0)

给定一套

{0, 1, 2, 3}

生成子集的好方法是什么:

[set(),
 {0},
 {1},
 {2},
 {3},
 {0, 1},
 {0, 2},
 {0, 3},
 {1, 2},
 {1, 3},
 {2, 3},
 {0, 1, 2},
 {0, 1, 3},
 {0, 2, 3},
 {1, 2, 3},
 {0, 1, 2, 3}]

我试图生成所有可能的方法来交错Python中的任意两个任意字符串.

例如:如果两个字符串是'ab'和'cd',我希望获得的输出是:

['abcd', 'acbd', 'acdb', 'cabd', 'cadb', 'cdab']

a总是在b(c之前d)之前看到.我正在努力寻找解决方案.我尝试过如下所示的itertools:

import itertools

def shuffle(s,t):
    string = s+t
    for i in itertools.permutations(string):
        print(''.join(i))

shuffle('ab','cd')

但正如预期的那样,这将返回所有可能的排列,而忽略了a和b(c和d)的顺序.

我一直在尝试一些技术,但我确信这是完成这项工作的顺利方法.

假设我有两个列表,其中包含相同数量的项目(每个4个):

a = ['a', 'b', 'c', 'd']    
b = [1, 2, 3, 4]

我想在保留订单的同时以所有可能的方式合并这些列表.示例输出:

a, b, c, d, 1, 2, 3, 4    
1, 2, 3, 4, a, b, c, d    
a, b, 1, 2, c, 3, 4, d

关键是每个列表必须保留其顺序,因此考虑到它在列表中的位置,项目不能在输出中的另一个项目之前.所以例如输出不能是:

a, b, **d**, c, 1...   > d precedes c whereas c is before d in the original list
1, **4**, a, b, 3....  > 4 precedes 3 whereas 3 is before 4 in the original list

我想这个想法是以所有可能的方式将第二个列表合并到第一个列表中.一个完全有效的例子是这样的:

a = [a, …

问题是打印两个给定字符串的所有可能的交错.所以我用Python编写了一个工作代码,运行方式如下:

def inter(arr1,arr2,p1,p2,arr):
    thisarr = copy(arr)
    if p1 == len(arr1) and p2 == len(arr2):
        printarr(thisarr)
    elif p1 == len(arr1):
        thisarr.extend(arr2[p2:])
        printarr(thisarr)
    elif p2 == len(arr2):
        thisarr.extend(arr1[p1:])
        printarr(thisarr)
    else:
        thisarr.append(arr1[p1])
        inter(arr1,arr2,p1+1,p2,thisarr)
        del thisarr[-1]
        thisarr.append(arr2[p2])
        inter(arr1,arr2,p1,p2+1,thisarr)
    return

它出现在字符串中的每个点上,然后对于一个递归调用,它将当前元素视为属于第一个数组,并在下一个调用中将其视为属于另一个数组.因此,如果输入的字符串ab和cd,它打印出来abcd,acbd,cdab,cabd,等p1,并p2都指向数组(因为Python中的字符串是不可改变的,我使用数组!).任何人都可以告诉我,这段代码的复杂程度是什么,是否可以改进？我编写了一个类似的代码来打印k给定数组的所有长度组合:

def kcomb(arr,i,thisarr,k):
     thisarr = copy(thisarr)
     j,n = len(thisarr),len(arr)
     if n-i<k-j or j >k:
        return
     if j==k:
        printarr(thisarr)
        return
     if i == n:
         return
     thisarr.append(arr[i])
     kcomb(arr,i+1,thisarr,k)
     del …

使用该itertools工具,我有给定的数字列表的所有可能的排列,但如果列表如下:

List=[0,0,0,0,3,6,0,0,5,0,0]

itertools 并不"知道"迭代零是浪费的工作,例如以下迭代将出现在结果中:

List=[0,3,0,0,0,6,0,0,5,0,0]

List=[0,3,0,0,0,6,0,0,5,0,0]

它们是相同的但itertools只是取第一个零(例如)并将其移动到列表中的第四个位置,反之亦然.

问题是:我如何只迭代一些选定的数字并单独留下其他如零？它可以有或没有itertools.

给定一个值列表，例如vec![0, 0, 1, 2]，我想创建一个迭代器来生成其所有独特的排列。那是，

[0, 0, 1, 2]
[0, 0, 2, 1]
[0, 1, 0, 2]
[0, 1, 2, 0]
[0, 2, 0, 1]
[0, 2, 1, 0]
[1, 0, 0, 2]
[1, 0, 2, 0]
[1, 2, 0, 0]
[2, 0, 0, 1]
[2, 0, 1, 0]
[2, 1, 0, 0]

（请注意，有 12 种不同的排列，而如果我们有 4 个不同的元素，则会有 24 种不同的排列）。

已经有一种方法可以使用itertools 包生成排列（以及其他迭代器，如组合或没有替换的组合），但对于排列，没有办法将排列限制为唯一的排列。

有一种相当有效的算法来生成排列，通常称为堆算法，但这并没有考虑值的相等性/重复性。

这个问题在带有生成器的语言中实现并不是太棘手，比如 Python，但我觉得这在 Rust 中更棘手（至少与上面的解决方案相比），因为它需要使用迭代器（它必须保持内部状态） ，或使用生成器（目前不稳定）。

我想迭代一个n大小为1 的维立方体的所有顶点.我知道我可以这样做,itertools.product如下所示:

>>> n = 3
>>> for j in it.product((0,1), repeat=n) :
...     print j
... 
(0, 0, 0)
(0, 0, 1)
(0, 1, 0)
(0, 1, 1)
(1, 0, 0)
(1, 0, 1)
(1, 1, 0)
(1, 1, 1)

但我需要区别对待每个顶点,这取决于1在其坐标中找到的s 的数量,即(0, 1, 1),(1, 0, 1)并且 (1, 1, 0)都将接收相同的tratment,因为它们都有两个1s.而不是使用上面的迭代器,然后计算1s 的数量,我想生成按1s 的数量排序的笛卡尔积,类似于:

>>> for ones in xrange(n) :
...     for seq in magic_expression(ones, …

想象一下，您正尝试n=10在一定数量的区域（例如 ）上分配一些固定资源（例如t=5）。我正在尝试有效地找出如何获得总和等于n或低于的所有组合。

例如10,0,0,0,0是好的，等等0,0,5,5,0，而3,3,3,3,3,3显然是错误的。

我到目前为止：

import itertools
t = 5
n = 10
r = [range(n+1)] * t
for x in itertools.product(*r): 
   if sum(x) <= n:          
       print x

然而，这种蛮力方法的速度非常慢；一定会有更好的办法？

计时（1000 次迭代）：

Default (itertools.product)           --- time: 40.90 s
falsetru recursion                    --- time:  3.63 s
Aaron Williams Algorithm (impl, Tony) --- time:  0.37 s

我正在尝试生成诸如“0000011111”或“000 11 2222 333”之类的字符串的所有可能排列。我尝试在“0000011111”上使用itertools 的排列，如下所示：

from itertools import permutations

basestring = "0"*5 +"1"*5 
perms = [''.join(p) for p in permutations(basestring)]
print(len(perms), perms)
print(len(set(perms)), set(perms))

Start with 2 characters        "0000 1111"
Move right most 0 over one     "0001 0111" and add it to the list
Continue moving it to the end  "0001 1011" -> "0001 1101" -> "0001 1110"

Now move …