Генерация перестановок с повторениями

Ответ 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)

Ответ 2

Вы не ищете перестановки - вы хотите Декартовой продукт. Для этого используйте product из itertools:

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

Ответ 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)]

Ответ 4

В этом случае понимание списка не требуется.

Учитывая

import itertools as it


iter_ = range(1, 7)
r = 2

код

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

Подробнее

Очевидно, что декартово произведение может генерировать подмножества перестановок. Однако из этого следует, что:

• с заменой: можно получить все перестановки n ** 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))  

Ответ 5

Сначала вам нужно сначала включить генератор, возвращенный itertools.permutations(list) в список. Затем, во-вторых, вы можете использовать set() для удаления дубликатов Что-то вроде ниже:

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

Ответ 6

Вот версия С# (хотя ее попросили 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;
            }
        }