具有唯一值的排列

itertools.permutations会根据其位置而不是其值来生成其元素被视为唯一的元素。所以基本上我想避免重复：

>>> list(itertools.permutations([1, 1, 1]))
[(1, 1, 1), (1, 1, 1), (1, 1, 1), (1, 1, 1), (1, 1, 1), (1, 1, 1)]

之后的过滤是不可能的，因为在我的情况下，排列的数量太大。

有人知道合适的算法吗？

非常感谢你！

编辑：

我基本上想要的是以下内容：

x = itertools.product((0, 1, 'x'), repeat=X)
x = sorted(x, key=functools.partial(count_elements, elem='x'))

这是不可能的，因为sorted创建列表并且itertools.product的输出太大。

抱歉，我应该已经描述了实际问题。

class unique_element:
    def __init__(self,value,occurrences):
        self.value = value
        self.occurrences = occurrences

def perm_unique(elements):
    eset=set(elements)
    listunique = [unique_element(i,elements.count(i)) for i in eset]
    u=len(elements)
    return perm_unique_helper(listunique,[0]*u,u-1)

def perm_unique_helper(listunique,result_list,d):
    if d < 0:
        yield tuple(result_list)
    else:
        for i in listunique:
            if i.occurrences > 0:
                result_list[d]=i.value
                i.occurrences-=1
                for g in  perm_unique_helper(listunique,result_list,d-1):
                    yield g
                i.occurrences+=1




a = list(perm_unique([1,1,2]))
print(a)

结果：

[(2, 1, 1), (1, 2, 1), (1, 1, 2)]

编辑（这是如何工作的）：

我将上面的程序改写得更长，但可读性更好。

我通常很难解释一些事情，但是让我尝试一下。为了了解它是如何工作的，您必须了解一个类似但更简单的程序，该程序将产生所有带有重复的排列。

def permutations_with_replacement(elements,n):
    return permutations_helper(elements,[0]*n,n-1)#this is generator

def permutations_helper(elements,result_list,d):
    if d<0:
        yield tuple(result_list)
    else:
        for i in elements:
            result_list[d]=i
            all_permutations = permutations_helper(elements,result_list,d-1)#this is generator
            for g in all_permutations:
                yield g

这个程序显然要简单得多：d代表permutations_helper中的depth并具有两个功能。一个函数是递归算法的停止条件，另一个函数用于传递的结果列表。

我们不返回每个结果，而是产生它。如果没有函数/运算符，yield则必须在停止条件时将结果推送到某个队列中。但是通过这种方式，一旦满足停止条件，结果就会通过所有堆栈传播到调用者。这样做的目的是
for g in perm_unique_helper(listunique,result_list,d-1): yield g 使每个结果都传播给调用者。

回到原始程序：我们有一个独特元素列表。在使用每个元素之前，我们必须检查仍有多少个元素可以推送到result_list上。使用此程序非常类似于permutations_with_replacement。区别在于，每个元素的重复次数不能超过perm_unique_helper中的重复次数。

因为有时新问题被标记为重复问题，并且他们的作者被提到此问题，所以可能有必要提及sympy为此目的有一个迭代器。

>>> from sympy.utilities.iterables import multiset_permutations
>>> list(multiset_permutations([1,1,1]))
[[1, 1, 1]]
>>> list(multiset_permutations([1,1,2]))
[[1, 1, 2], [1, 2, 1], [2, 1, 1]]

这依赖于实现细节，即排序的可迭代对象的任何排列都是按排序顺序进行的，除非它们是先前排列的重复。

from itertools import permutations

def unique_permutations(iterable, r=None):
    previous = tuple()
    for p in permutations(sorted(iterable), r):
        if p > previous:
            previous = p
            yield p

for p in unique_permutations('cabcab', 2):
    print p

给

('a', 'a')
('a', 'b')
('a', 'c')
('b', 'a')
('b', 'b')
('b', 'c')
('c', 'a')
('c', 'b')
('c', 'c')

大约和Luka Rahne的回答一样快，但是更简短，更简单，恕我直言。

def unique_permutations(elements):
    if len(elements) == 1:
        yield (elements[0],)
    else:
        unique_elements = set(elements)
        for first_element in unique_elements:
            remaining_elements = list(elements)
            remaining_elements.remove(first_element)
            for sub_permutation in unique_permutations(remaining_elements):
                yield (first_element,) + sub_permutation

>>> list(unique_permutations((1,2,3,1)))
[(1, 1, 2, 3), (1, 1, 3, 2), (1, 2, 1, 3), ... , (3, 1, 2, 1), (3, 2, 1, 1)]

它通过设置第一个元素（遍历所有唯一元素）并遍历所有其余元素的排列来递归工作。

让我们浏览unique_permutations（1,2,3,1）的，看看它是如何工作的：

• unique_elements 是1,2,3
• 让我们遍历它们：first_element从1开始。
  • remaining_elements 是[2,3,1]（即1,2,3,1减去前1个）
  • 我们（递归）遍历其余元素的排列：（1、2、3），（1、3、2），（2、1、3），（2、3、1），（3、1 2），（3、2、1）
  • 对于每一个sub_permutation，我们插入first_element：（1，1,2,3），（1，1,3,2），......并产生结果。
• 现在我们迭代到first_element= 2，并执行与上面相同的操作。
  • remaining_elements 是[1,3,1]（即1,2,3,1减去前2个）
  • 我们遍历其余元素的排列：（1、1、3），（1、3、1），（3、1、1）
  • 对于每一个sub_permutation，我们插入first_element：（2，1，1，3），（2，1，3，1），（2，3，1,1）...和得到的结果。
• 最后，我们对first_element= 3进行相同操作。

您可以尝试使用set：

>>> list(itertools.permutations(set([1,1,2,2])))
[(1, 2), (2, 1)]

设置删除的重复项的调用

这是我的10行解决方案：

class Solution(object):
    def permute_unique(self, nums):
        perms = [[]]
        for n in nums:
            new_perm = []
            for perm in perms:
                for i in range(len(perm) + 1):
                    new_perm.append(perm[:i] + [n] + perm[i:])
                    # handle duplication
                    if i < len(perm) and perm[i] == n: break
            perms = new_perm
        return perms


if __name__ == '__main__':
    s = Solution()
    print s.permute_unique([1, 1, 1])
    print s.permute_unique([1, 2, 1])
    print s.permute_unique([1, 2, 3])

-结果-

[[1, 1, 1]]
[[1, 2, 1], [2, 1, 1], [1, 1, 2]]
[[3, 2, 1], [2, 3, 1], [2, 1, 3], [3, 1, 2], [1, 3, 2], [1, 2, 3]]

天真的方法可能是采用一组排列：

list(set(it.permutations([1, 1, 1])))
# [(1, 1, 1)]

但是，此技术浪费了计算重复排列并丢弃它们的过程。一种更有效的方法是more_itertools.distinct_permutations使用第三方工具。

码

import itertools as it

import more_itertools as mit


list(mit.distinct_permutations([1, 1, 1]))
# [(1, 1, 1)]

性能

使用更大的迭代器，我们将比较幼稚和第三方技术的性能。

iterable = [1, 1, 1, 1, 1, 1]
len(list(it.permutations(iterable)))
# 720

%timeit -n 10000 list(set(it.permutations(iterable)))
# 10000 loops, best of 3: 111 µs per loop

%timeit -n 10000 list(mit.distinct_permutations(iterable))
# 10000 loops, best of 3: 16.7 µs per loop

我们看到more_itertools.distinct_permutations速度快了一个数量级。

细节

从源头来看，递归算法（如在接受的答案中所示）用于计算不同的排列，从而避免了浪费的计算。请参阅源代码以获取更多详细信息。

这是该问题的递归解决方案。

def permutation(num_array):
    res=[]
    if len(num_array) <= 1:
        return [num_array]
    for num in set(num_array):
        temp_array = num_array.copy()
        temp_array.remove(num)
        res += [[num] + perm for perm in permutation(temp_array)]
    return res

arr=[1,2,2]
print(permutation(arr))

听起来您正在寻找itertools.combinations（）docs.python.org

list(itertools.combinations([1, 1, 1],3))
[(1, 1, 1)]

自己找东西的时候碰到了这个问题！

这是我所做的：

def dont_repeat(x=[0,1,1,2]): # Pass a list
    from itertools import permutations as per
    uniq_set = set()
    for byt_grp in per(x, 4):
        if byt_grp not in uniq_set:
            yield byt_grp
            uniq_set.update([byt_grp])
    print uniq_set

for i in dont_repeat(): print i
(0, 1, 1, 2)
(0, 1, 2, 1)
(0, 2, 1, 1)
(1, 0, 1, 2)
(1, 0, 2, 1)
(1, 1, 0, 2)
(1, 1, 2, 0)
(1, 2, 0, 1)
(1, 2, 1, 0)
(2, 0, 1, 1)
(2, 1, 0, 1)
(2, 1, 1, 0)
set([(0, 1, 1, 2), (1, 0, 1, 2), (2, 1, 0, 1), (1, 2, 0, 1), (0, 1, 2, 1), (0, 2, 1, 1), (1, 1, 2, 0), (1, 2, 1, 0), (2, 1, 1, 0), (1, 0, 2, 1), (2, 0, 1, 1), (1, 1, 0, 2)])

基本上，制作一组并继续添加。胜过列出占用过多内存的列表等。希望它能帮助下一个查找的人:-)在函数中注释掉设置的“更新”以查看区别。

我见过的解决此问题的最佳方法是使用Knuth的“算法L”（如Gerrat先前在原始帖子的评论中指出的那样）：http ://stackoverflow.com/questions/12836385/how-can-i-interleave-
或创建没有重复的两个设置的唯一置换/ 12837695

一些时间：

排序[1]*12+[0]*12（2,704,156个唯一置换）：
算法L→2.43 s
Luke Rahne解→8.56 s
scipy.multiset_permutations()→16.8 s

您可以创建一个函数，该函数用于collections.Counter从给定序列中获取唯一项及其计数，并用于itertools.combinations为每个递归调用中的每个唯一项选择索引组合，并在选择所有索引时将索引映射回列表：

from collections import Counter
from itertools import combinations
def unique_permutations(seq):
    def index_permutations(counts, index_pool):
        if not counts:
            yield {}
            return
        (item, count), *rest = counts.items()
        rest = dict(rest)
        for indices in combinations(index_pool, count):
            mapping = dict.fromkeys(indices, item)
            for others in index_permutations(rest, index_pool.difference(indices)):
                yield {**mapping, **others}
    indices = set(range(len(seq)))
    for mapping in index_permutations(Counter(seq), indices):
        yield [mapping[i] for i in indices]

这样[''.join(i) for i in unique_permutations('moon')]返回：

['moon', 'mono', 'mnoo', 'omon', 'omno', 'nmoo', 'oomn', 'onmo', 'nomo', 'oonm', 'onom', 'noom']

要生成["A","B","C","D"]我的唯一排列，请使用以下命令：

from itertools import combinations,chain

l = ["A","B","C","D"]
combs = (combinations(l, r) for r in range(1, len(l) + 1))
list_combinations = list(chain.from_iterable(combs))

产生：

[('A',),
 ('B',),
 ('C',),
 ('D',),
 ('A', 'B'),
 ('A', 'C'),
 ('A', 'D'),
 ('B', 'C'),
 ('B', 'D'),
 ('C', 'D'),
 ('A', 'B', 'C'),
 ('A', 'B', 'D'),
 ('A', 'C', 'D'),
 ('B', 'C', 'D'),
 ('A', 'B', 'C', 'D')]

注意，不会创建重复项（例如，与之组合的项D不会生成，因为它们已经存在）。

示例：然后可以将其用于通过Pandas数据帧中的数据为OLS模型生成高阶或低阶项。

import statsmodels.formula.api as smf
import pandas as pd

# create some data
pd_dataframe = pd.Dataframe(somedata)
response_column = "Y"

# generate combinations of column/variable names
l = [col for col in pd_dataframe.columns if col!=response_column]
combs = (combinations(l, r) for r in range(1, len(l) + 1))
list_combinations = list(chain.from_iterable(combs))

# generate OLS input string
formula_base = '{} ~ '.format(response_column)
list_for_ols = [":".join(list(item)) for item in list_combinations]
string_for_ols = formula_base + ' + '.join(list_for_ols)

创建...

Y ~ A + B + C + D + A:B + A:C + A:D + B:C + B:D + C:D + A:B:C + A:B:D + A:C:D + B:C:D + A:B:C:D'

然后可以将其通过管道传输到您的OLS回归

model = smf.ols(string_for_ols, pd_dataframe).fit()
model.summary()

前几天在解决我自己的问题时遇到了这个问题。我喜欢Luka Rahne的方法，但是我认为在集合库中使用Counter类似乎是一个适度的改进。这是我的代码：

def unique_permutations(elements):
    "Returns a list of lists; each sublist is a unique permutations of elements."
    ctr = collections.Counter(elements)

    # Base case with one element: just return the element
    if len(ctr.keys())==1 and ctr[ctr.keys()[0]] == 1:
        return [[ctr.keys()[0]]]

    perms = []

    # For each counter key, find the unique permutations of the set with
    # one member of that key removed, and append the key to the front of
    # each of those permutations.
    for k in ctr.keys():
        ctr_k = ctr.copy()
        ctr_k[k] -= 1
        if ctr_k[k]==0: 
            ctr_k.pop(k)
        perms_k = [[k] + p for p in unique_permutations(ctr_k)]
        perms.extend(perms_k)

    return perms

此代码将每个排列作为列表返回。如果您给它提供一个字符串，它将为您提供一个排列列表，其中每个排列都是一个字符列表。如果您希望将输出显示为字符串列表（例如，如果您是一个糟糕的人，并且想要滥用我的代码来帮助您在Scrabble中作弊），请执行以下操作：

[''.join(perm) for perm in unique_permutations('abunchofletters')]

在这种情况下，我想出了一个使用itertools.product的非常合适的实现（这是您需要所有组合的实现

unique_perm_list = [''.join(p) for p in itertools.product(['0', '1'], repeat = X) if ''.join(p).count() == somenumber]

这本质上是n = X和somenumber = k itertools.product（）的组合（在n上超过k），从k = 0迭代到k = X，随后进行带计数的过滤可确保仅将正确数量的1的排列转换为一个列表。当您计算k上的n并将其与len（unique_perm_list）比较时，您可以轻松地看到它起作用

为了消除递归，请使用字典和numba以获得高性能，但不使用yield / generator样式，因此内存使用不受限制：

import numba

@numba.njit
def perm_unique_fast(elements): #memory usage too high for large permutations
    eset = set(elements)
    dictunique = dict()
    for i in eset: dictunique[i] = elements.count(i)
    result_list = numba.typed.List()
    u = len(elements)
    for _ in range(u): result_list.append(0)
    s = numba.typed.List()
    results = numba.typed.List()
    d = u
    while True:
        if d > 0:
            for i in dictunique:
                if dictunique[i] > 0: s.append((i, d - 1))
        i, d = s.pop()
        if d == -1:
            dictunique[i] += 1
            if len(s) == 0: break
            continue
        result_list[d] = i
        if d == 0: results.append(result_list[:])
        dictunique[i] -= 1
        s.append((i, -1))
    return results

import timeit
l = [2, 2, 3, 3, 4, 4, 5, 5, 6, 6]
%timeit list(perm_unique(l))
#377 ms ± 26 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

ltyp = numba.typed.List()
for x in l: ltyp.append(x)
%timeit perm_unique_fast(ltyp)
#293 ms ± 3.37 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

assert list(sorted(perm_unique(l))) == list(sorted([tuple(x) for x in perm_unique_fast(ltyp)]))

速度提高了约30％，但由于列表复制和管理仍然受到影响。

或者，不使用numba，但仍然不使用递归，并使用生成器来避免内存问题：

def perm_unique_fast_gen(elements):
    eset = set(elements)
    dictunique = dict()
    for i in eset: dictunique[i] = elements.count(i)
    result_list = list() #numba.typed.List()
    u = len(elements)
    for _ in range(u): result_list.append(0)
    s = list()
    d = u
    while True:
        if d > 0:
            for i in dictunique:
                if dictunique[i] > 0: s.append((i, d - 1))
        i, d = s.pop()
        if d == -1:
            dictunique[i] += 1
            if len(s) == 0: break
            continue
        result_list[d] = i
        if d == 0: yield result_list
        dictunique[i] -= 1
        s.append((i, -1))

这是我尝试不使用set / dict作为使用递归的生成器，而是使用字符串作为输入的尝试。输出也以自然顺序排序：

def perm_helper(head: str, tail: str):
    if len(tail) == 0:
        yield head
    else:
        last_c = None
        for index, c in enumerate(tail):
            if last_c != c:
                last_c = c
                yield from perm_helper(
                    head + c, tail[:index] + tail[index + 1:]
                )


def perm_generator(word):
    yield from perm_helper("", sorted(word))

例：

from itertools import takewhile
word = "POOL"
list(takewhile(lambda w: w != word, (x for x in perm_generator(word))))
# output
# ['LOOP', 'LOPO', 'LPOO', 'OLOP', 'OLPO', 'OOLP', 'OOPL', 'OPLO', 'OPOL', 'PLOO', 'POLO']

关于什么

np.unique(itertools.permutations([1, 1, 1]))

问题在于排列现在是Numpy数组的行，因此使用了更多的内存，但是您可以像以前一样循环遍历它们

perms = np.unique(itertools.permutations([1, 1, 1]))
for p in perms:
    print p

ans=[]
def fn(a, size): 
    if (size == 1): 
        if a.copy() not in ans:
            ans.append(a.copy())
            return

    for i in range(size): 
        fn(a,size-1); 
        if size&1: 
            a[0], a[size-1] = a[size-1],a[0] 
        else: 
            a[i], a[size-1] = a[size-1],a[i]

https://www.geeksforgeeks.org/heaps-algorithm-for-generating-permutations/