更好

Question

我知道itertools，但它似乎只能生成排列而不重复。

例如，我想为2个骰子生成所有可能的骰子。所以我需要[1,2,3,4,5,6]的大小为2的所有排列，包括重复：（1,1），（1,2），（2,1）...等等

如果可能，我不想从头开始实施

Answer 1

在数学中，笛卡尔积（或产品集）是两组的直接乘积。

在您的情况下，这将是{1, 2, 3, 4, 5, 6} x {1, 2, 3, 4, 5, 6}。 itertools可以帮助您：

import itertools
x = [1, 2, 3, 4, 5, 6]
[p for p in itertools.product(x, repeat=2)]
[(1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 1), (2, 2), (2, 3), 
 (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), 
 (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 1), (5, 2), (5, 3), 
 (5, 4), (5, 5), (5, 6), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6)]

获得随机掷骰子（以完全低效的方式）：

import random
random.choice([p for p in itertools.product(x, repeat=2)])
(6, 3)

Answer 2

你不是在寻找排列 - 你想要Cartesian Product。为此，使用来自itertools的product：

from itertools import product
for roll in product([1, 2, 3, 4, 5, 6], repeat = 2):
    print(roll)

Answer 3

在python 2.7和3.1中有一个itertools.combinations_with_replacement函数：

>>> list(itertools.combinations_with_replacement([1, 2, 3, 4, 5, 6], 2))
[(1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 2), (2, 3), (2, 4), 
 (2, 5), (2, 6), (3, 3), (3, 4), (3, 5), (3, 6), (4, 4), (4, 5), (4, 6),
 (5, 5), (5, 6), (6, 6)]

Answer 4

在这种情况下，不需要特别的列表理解。

给出

import itertools as it


iter_ = range(1, 7)
r = 2

代码

list(it.product(iter_, repeat=r))

详细信息

显然，笛卡尔积可以生成排列的子集。但是，它遵循以下条件：

替换：可以通过product
无需更换：一个可以从后者中过滤掉

置换置换n ** r

[x for x in it.product(iter_, repeat=r)]

没有替换的排列，n！

[x for x in it.product(iter_, repeat=r) if len(set(x)) == r]

# Equivalent
list(it.permutations(iter_, r))

Answer 5

首先，您希望先将itertools.permutations（list）返回的生成器转换为列表。其次，您可以使用set（）删除重复项如下所示：

def permutate(a_list):
    import itertools
    return set(list(itertools.permutations(a_list)))

Answer 6

我认为我找到了仅使用lambdas，map和reduce的解决方案。

product_function = lambda n: reduce(lambda x, y: x+y, map(lambda i: list(map(lambda j: (i, j), np.arange(n))), np.arange(n)), [])

基本上，我正在映射第一个给定一行的lambda函数，该函数迭代列数

list(map(lambda j: (i, j), np.arange(n)))

然后将其用作新的lambda函数的输出

lambda i:list(map(lambda j: (i, j), np.arange(n)))

映射到所有可能的行

map(lambda i: list(map(lambda j: (i, j), np.arange(n))), np.arange(m))

然后将所有结果列表简化为一个。

更好

也可以使用两个不同的数字。

prod= lambda n, m: reduce(lambda x, y: x+y, map(lambda i: list(map(lambda j: (i, j), np.arange(m))), np.arange(n)), [])

Answer 7

这是c＃版本（即使它要求python，算法应该相同）仅供参考：

下面的方法基本上没有。有时可以掷骰子以获得各种排列。对于上述问题，大小应为“2”。

private void GetAllPermutationsOfDice_Recursive(int size, string currentValue, 
            List<string> values)
        {
            if(currentValue.Length == size)
            {
                values.Add(currentValue);
                return;
            }
            for(int i = 1; i<=6;i++)
            {
                this.GetAllPermutationsOfDice_Recursive(size, currentValue + i, values);   
            }
        }

要掷骰子两次，可以将上述方法称为：

public string[] GetAllPermutationsOfDiceOfSize_2()
        {
            List<string> values = new List<string>();
            this.GetAllPermutationsOfDice_Recursive(2, "", values);
            return values.ToArray();
        }

以下是相应的单元测试：

[TestMethod]
        public void Dice_PermutationsTests()
        {
            var v = this.GetAllPermutationsOfDiceOfSize_2();
            Assert.AreEqual(36, v.Length);
            int l = 6;
            List<string> values = new List<string>();
            for(int i = 1; i<=4; i++)
            {
                values.Clear();
                this.GetAllPermutationsOfDice_Recursive(i, "", values);
                Assert.AreEqual(l, values.Count);
                l *= 6;
            }
        }

在python中重复生成排列

7 个答案:

更好