Question

我正在尝试生成从一组数字派生的三个数字的所有可能组合假设我有数字1到9（每次一个）我想生成三倍数字，如14, 983, 7256（但所有可能的组合）。因此，每个数字只能使用一次，并且必须使用所有数字。

我的第一个想法是为每个数字生成不同的数字集合，如下所示：

bin_arr = []
for i in range(1, 512):
    bin_arr.append([int(a) for a in ("{0:0b}".format(i))])

>>> bin_arr[257]
>>> [1, 0, 0, 0, 0, 0, 0, 0, 1]

和compress这些'123456789'，但似乎无处可去。

有没有办法以聪明的方式做到这一点？

Answer 1

我们可以假设一个像[14,983,2567]这样的列表是一个数字序列149832567，然后我们为它添加两个逗号，一个在4之后，另一个在3之后，所以我们生成三个数字[14,983,2567]

那么，可以生成多少个数字序列？

In [1]: import itertools

In [2]: a = range(1,10)

In [3]: a
Out[3]: [1, 2, 3, 4, 5, 6, 7, 8, 9]

In [4]: len(list(itertools.permutations(a,9)))
Out[4]: 362880

当我们得到像437865192这样的数字序列时，可以生成多少个三元组？组合

8 * 7/2 = 28（在9个数字之间选择两个间隙）

或使用itertools.combinations

In [8]: len(list(itertools.combinations(list(range(8)),2)))
Out[8]: 28

给出一个序列，我们将得到28个组合。

In [1]: a = ['2','3','6','4','9','1','7','8','5']

In [2]: import itertools

In [4]: for i in itertools.combinations(range(1,9),2):
...:     print [int(''.join(a[:i[0]])), int(''.join(a[i[0]:i[1]])), int(''.join(a[i[1]:]))]

[2, 3, 6491785]
[2, 36, 491785]
[2, 364, 91785]
[2, 3649, 1785]
[2, 36491, 785]
[2, 364917, 85]
[2, 3649178, 5]
[23, 6, 491785]
[23, 64, 91785]
[23, 649, 1785]
[23, 6491, 785]
[23, 64917, 85]
[23, 649178, 5]
[236, 4, 91785]
[236, 49, 1785]
[236, 491, 785]
[236, 4917, 85]
[236, 49178, 5]
[2364, 9, 1785]
[2364, 91, 785]
[2364, 917, 85]
[2364, 9178, 5]
[23649, 1, 785]
[23649, 17, 85]
[23649, 178, 5]
[236491, 7, 85]
[236491, 78, 5]
[2364917, 8, 5]

所以会生成10160640（362880 * 28）个列表。

最终版代码：

In [15]: a=map(lambda x:str(x), range(1,10))

In [16]: a
Out[16]: ['1', '2', '3', '4', '5', '6', '7', '8', '9']

In [17]: result = []

In [18]: for seq in itertools.permutations(a,9):
    ...:     for i in itertools.combinations(range(1,9),2):
    ...:         result.append([int(''.join(seq[:i[0]])), int(''.join(seq[i[0]:i[1]])), int(''.join(seq[i[1]:]))])
    ...:

In [19]: len(result)
Out[19]: 10160640

Answer 2

假设订单很重要，我就是这样做的。

@ outcome是所需选项的列表，例如如果你想要一个数字为0-9的数字，请使用输出[0,1，... 。。，9]。

@length是每个输出数字中的位数。您在问题中使用了最多4位数，我假设有一些上限。

使用下面的函数为三元组的每个部分生成排列，然后将结果反馈以生成进一步的排列。

def gen_permutations(outcomes, length):
        ans = set([()])
        for dummy_idx in range(length):
            temp = set()
            for seq in ans: 
                for item in outcomes: #each possible outcome
                    new_seq = list(seq)
                    if len(outcomes) == 1 or item in new_seq:
                        continue
                    new_seq.append(item)
                    temp.add(tuple(new_seq))
            ans = temp

        return ans

从一组数字生成数字

2 个答案: