リストのすべての順列を生成する方法は?


592

リスト内の要素のタイプに関係なく、Pythonでリストのすべての順列をどのように生成しますか?

例えば:

permutations([])
[]

permutations([1])
[1]

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

permutations([1, 2, 3])
[1, 2, 3]
[1, 3, 2]
[2, 1, 3]
[2, 3, 1]
[3, 1, 2]
[3, 2, 1]

5
私は再帰的な受け入れられた答えに同意します-今日。ただし、これは依然として巨大なコンピューターサイエンスの問題として存在しています。受け入れ答えは、指数関数的複雑さ(2 ^ NN = LEN(リスト))、それを解決して、この問題を解決(またはあなたができないことを証明)多項式時間:)を参照してください「巡回セールスマン問題」で
FlipMcF

38
@FlipMcF出力を列挙するだけでも階乗時間がかかることを考えると、多項式時間で「解決」することは困難です...したがって、それは不可能です。
トーマス

回答:


489

Python 2.6以降(およびPython 3を使用している場合)、このための標準ライブラリツールがありますitertools.permutations

import itertools
list(itertools.permutations([1, 2, 3]))

何らかの理由で古いPython(2.6未満)を使用している場合、またはそれがどのように機能するか知りたいだけの場合は、http//code.activestate.com/recipes/252178/から抜粋した 1つの優れたアプローチを 次に示します

def all_perms(elements):
    if len(elements) <=1:
        yield elements
    else:
        for perm in all_perms(elements[1:]):
            for i in range(len(elements)):
                # nb elements[0:1] works in both string and list contexts
                yield perm[:i] + elements[0:1] + perm[i:]

のドキュメントには、いくつかの代替アプローチがリストされていますitertools.permutations。ここに一つあります:

def permutations(iterable, r=None):
    # permutations('ABCD', 2) --> AB AC AD BA BC BD CA CB CD DA DB DC
    # permutations(range(3)) --> 012 021 102 120 201 210
    pool = tuple(iterable)
    n = len(pool)
    r = n if r is None else r
    if r > n:
        return
    indices = range(n)
    cycles = range(n, n-r, -1)
    yield tuple(pool[i] for i in indices[:r])
    while n:
        for i in reversed(range(r)):
            cycles[i] -= 1
            if cycles[i] == 0:
                indices[i:] = indices[i+1:] + indices[i:i+1]
                cycles[i] = n - i
            else:
                j = cycles[i]
                indices[i], indices[-j] = indices[-j], indices[i]
                yield tuple(pool[i] for i in indices[:r])
                break
        else:
            return

そして別の、に基づいてitertools.product

def permutations(iterable, r=None):
    pool = tuple(iterable)
    n = len(pool)
    r = n if r is None else r
    for indices in product(range(n), repeat=r):
        if len(set(indices)) == r:
            yield tuple(pool[i] for i in indices)

14
これと他の再帰的ソリューションは、並べ替えられたリストが十分に大きい場合、すべてのRAMを
消費

3
それらはまた、大きなリストで再帰の限界に達し(そして死ぬ)
dbr

58
bgbg、dbr:ジェネレータを使用しているため、関数自体がメモリを消費しません。all_permsによって返されたイテレータをどのように使用するかはあなたに任されています(たとえば、各反復をディスクに書き込み、メモリについて心配する必要はありません)。私はこの投稿が古いことを知っていますが、今読んでいる皆のためにこれを書いています。また、今では、多くの人が指摘しているように、最適な方法はitertools.permutations()を使用することです。
Jagtesh Chadha、

18
だけでなく、発電機。ネストされたジェネレーターを使用しており、不明な場合に備えて、それぞれが呼び出しスタックの前のジェネレーターに譲ります。これはO(n)メモリを使用します。
cdunn2001、2007

1
PS:for i in range(len(elements))ではなく、で修正しましたfor i in range(len(elements)+1)。実際、単一化された要素elements[0:1]len(elements)、結果ではなく、異なる位置にある可能性がありlen(elements)+1ます。
Eric O Lebigot、2012年

339

そしてPython 2.6以降:

import itertools
itertools.permutations([1,2,3])

(ジェネレータとして返されlist(permutations(l))ます。リストとして返すために使用します。)


15
Python 3でも動作します
ウィレフ2009

10
が存在することに注意してくださいrパラメータは、例えばitertools.permutations([1,2,3], r=2):2つの要素を選択するすべての可能な順列生成されます、[(1, 2), (1, 3), (2, 1), (2, 3), (3, 1), (3, 2)]
toto_tico

278

Python 2.6以降の次のコードのみ

まず、インポートitertools

import itertools

順列(順序が重要):

print list(itertools.permutations([1,2,3,4], 2))
[(1, 2), (1, 3), (1, 4),
(2, 1), (2, 3), (2, 4),
(3, 1), (3, 2), (3, 4),
(4, 1), (4, 2), (4, 3)]

組み合わせ(順序は関係ありません):

print list(itertools.combinations('123', 2))
[('1', '2'), ('1', '3'), ('2', '3')]

デカルト積(いくつかのイテラブル付き):

print list(itertools.product([1,2,3], [4,5,6]))
[(1, 4), (1, 5), (1, 6),
(2, 4), (2, 5), (2, 6),
(3, 4), (3, 5), (3, 6)]

デカルト積(1つの反復可能オブジェクトとそれ自体):

print list(itertools.product([1,2], repeat=3))
[(1, 1, 1), (1, 1, 2), (1, 2, 1), (1, 2, 2),
(2, 1, 1), (2, 1, 2), (2, 2, 1), (2, 2, 2)]


`print list(itertools.permutations([1,2,3,4]、2))^` SyntaxError:invalid syntax` VSコードの使用を開始したばかり何が悪いのでしょうか?ポインタは「リスト」の「t」の下を指しています
ガス

39
def permutations(head, tail=''):
    if len(head) == 0: print tail
    else:
        for i in range(len(head)):
            permutations(head[0:i] + head[i+1:], tail+head[i])

次のように呼ばれます:

permutations('abc')

なぜ尾を印刷してからNoneを返すのですか?代わりに尾を返さないのはなぜですか?とにかく何も返さないのはなぜですか?
bugmenot123 2017年

30
#!/usr/bin/env python

def perm(a, k=0):
   if k == len(a):
      print a
   else:
      for i in xrange(k, len(a)):
         a[k], a[i] = a[i] ,a[k]
         perm(a, k+1)
         a[k], a[i] = a[i], a[k]

perm([1,2,3])

出力:

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

リストのコンテンツを交換しているので、入力として可変シーケンスタイプが必要です。例えば、perm(list("ball"))動作しますとperm("ball")、あなたは文字列を変更することはできませんしませんので。

このPythonの実装は、Horowitz、Sahni、Rajasekeranの著書Computer Algorithmsで紹介されているアルゴリズムに触発されています。


kは長さまたは順列であると仮定します。k = 2出力の場合[1、2、3]。(1、2)(1、3)(2、1)(2、3)(3、1)(3、2)である必要はありませんか?
Konstantinos Monachopoulos

kは交換したい要素のインデックスです
sf8193

22

このソリューションは、ジェネレーターを実装して、メモリ上のすべての順列を保持しないようにします。

def permutations (orig_list):
    if not isinstance(orig_list, list):
        orig_list = list(orig_list)

    yield orig_list

    if len(orig_list) == 1:
        return

    for n in sorted(orig_list):
        new_list = orig_list[:]
        pos = new_list.index(n)
        del(new_list[pos])
        new_list.insert(0, n)
        for resto in permutations(new_list[1:]):
            if new_list[:1] + resto <> orig_list:
                yield new_list[:1] + resto

16

機能的なスタイルで

def addperm(x,l):
    return [ l[0:i] + [x] + l[i:]  for i in range(len(l)+1) ]

def perm(l):
    if len(l) == 0:
        return [[]]
    return [x for y in perm(l[1:]) for x in addperm(l[0],y) ]

print perm([ i for i in range(3)])

結果:

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

15

次のコードは、ジェネレーターとして実装された、所定のリストのインプレース置換です。リストへの参照のみを返すため、リストはジェネレータの外部で変更しないでください。ソリューションは非再帰的であるため、メモリ使用量が少なくなります。入力リスト内の要素の複数のコピーでもうまく機能します。

def permute_in_place(a):
    a.sort()
    yield list(a)

    if len(a) <= 1:
        return

    first = 0
    last = len(a)
    while 1:
        i = last - 1

        while 1:
            i = i - 1
            if a[i] < a[i+1]:
                j = last - 1
                while not (a[i] < a[j]):
                    j = j - 1
                a[i], a[j] = a[j], a[i] # swap the values
                r = a[i+1:last]
                r.reverse()
                a[i+1:last] = r
                yield list(a)
                break
            if i == first:
                a.reverse()
                return

if __name__ == '__main__':
    for n in range(5):
        for a in permute_in_place(range(1, n+1)):
            print a
        print

    for a in permute_in_place([0, 0, 1, 1, 1]):
        print a
    print

15

私の意見では非常に明白な方法はまたかもしれない:

def permutList(l):
    if not l:
            return [[]]
    res = []
    for e in l:
            temp = l[:]
            temp.remove(e)
            res.extend([[e] + r for r in permutList(temp)])

    return res

11
list2Perm = [1, 2.0, 'three']
listPerm = [[a, b, c]
            for a in list2Perm
            for b in list2Perm
            for c in list2Perm
            if ( a != b and b != c and a != c )
            ]
print listPerm

出力:

[
    [1, 2.0, 'three'], 
    [1, 'three', 2.0], 
    [2.0, 1, 'three'], 
    [2.0, 'three', 1], 
    ['three', 1, 2.0], 
    ['three', 2.0, 1]
]

2
技術的には望ましい出力を生成しますが、O(n ^ n)でO(n lg n)になる可能性のある問題を解決しています-大きなセットでは「わずかに」非効率的です。
ジェームズ

3
@ジェームズ:私はあなたが与えるO(n log n)に少し混乱しています:順列の数はn!で、これはすでにO(n log n)よりはるかに大きいです。そのため、解がO(n log n)になる方法がわかりません。ただし、スターリングの近似から明らかなように、この解はO(n ^ n)にあり、これはn!よりはるかに大きいです。
Eric O Lebigot、2012年

9

階乗数システムに基づくアルゴリズムを使用しました-長さnのリストの場合、各ステージで残っているアイテムから選択して、各順列アイテムをアイテムごとに組み立てることができます。最初の項目にはn個の選択肢、2番目にはn-1個、最後の項目には1個の選択肢しかないため、階乗数体系の数値の桁をインデックスとして使用できます。このように、0からn!-1までの数字は、辞書式順序で考えられるすべての順列に対応しています。

from math import factorial
def permutations(l):
    permutations=[]
    length=len(l)
    for x in xrange(factorial(length)):
        available=list(l)
        newPermutation=[]
        for radix in xrange(length, 0, -1):
            placeValue=factorial(radix-1)
            index=x/placeValue
            newPermutation.append(available.pop(index))
            x-=index*placeValue
        permutations.append(newPermutation)
    return permutations

permutations(range(3))

出力:

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

この方法は再帰的ではありませんが、私のコンピューターでは少し遅く、nの場合、xrangeはエラーを発生させます。Cの長整数に変換するには大きすぎます(私にとってはn = 13)。必要なときにそれで十分でしたが、ロングショットではitertools.permutationsではありません。


3
こんにちは、Stack Overflowへようこそ。ブルートフォースメソッドを投稿することにはメリットがありますが、ソリューションが承認されたソリューションより優れていると思わない場合は、投稿しないでください(特に、既に多くの回答がある古い質問について)。
Hannele 2013

1
私は実際には力ずくの非図書館的アプローチを探していたので、ありがとう!
ジェイテイラー

8

このアルゴリズムにはn factorial時間の複雑性があることに注意してください。ここnで、は入力リストの長さです

実行時に結果を印刷します。

global result
result = [] 

def permutation(li):
if li == [] or li == None:
    return

if len(li) == 1:
    result.append(li[0])
    print result
    result.pop()
    return

for i in range(0,len(li)):
    result.append(li[i])
    permutation(li[:i] + li[i+1:])
    result.pop()    

例:

permutation([1,2,3])

出力:

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

8

確かに、tzwennの答えのように、各順列の最初の要素を反復することができます。ただし、このソリューションを次のように記述する方が効率的です。

def all_perms(elements):
    if len(elements) <= 1:
        yield elements  # Only permutation possible = no permutation
    else:
        # Iteration over the first element in the result permutation:
        for (index, first_elmt) in enumerate(elements):
            other_elmts = elements[:index]+elements[index+1:]
            for permutation in all_perms(other_elmts): 
                yield [first_elmt] + permutation

このソリューションは、再帰がのlen(elements) <= 1代わりに終了するため、明らかに30%高速です0。またyield、Riccardo Reyesのソリューションのように、(を介して)ジェネレーター関数を使用するため、メモリ効率も大幅に向上します。


6

これは、リスト内包表記を使用したHaskell実装に触発されています。

def permutation(list):
    if len(list) == 0:
        return [[]]
    else:
        return [[x] + ys for x in list for ys in permutation(delete(list, x))]

def delete(list, item):
    lc = list[:]
    lc.remove(item)
    return lc

6

通常の実装(収量なし-メモリ内のすべてを実行します):

def getPermutations(array):
    if len(array) == 1:
        return [array]
    permutations = []
    for i in range(len(array)): 
        # get all perm's of subarray w/o current item
        perms = getPermutations(array[:i] + array[i+1:])  
        for p in perms:
            permutations.append([array[i], *p])
    return permutations

収量の実装:

def getPermutations(array):
    if len(array) == 1:
        yield array
    else:
        for i in range(len(array)):
            perms = getPermutations(array[:i] + array[i+1:])
            for p in perms:
                yield [array[i], *p]

基本的な考え方は、第一位置のアレイ内のすべての要素の上に移動し、第二の位置で第一のために選ばれた要素なしの要素のすべての残りの部分の上に行くことである、などあなたはでこれを行うことができます再帰、停止基準は1要素の配列に到達することです-その場合、その配列を返します。

ここに画像の説明を入力してください


これは私にとっては機能しません_> ValueError:オペランドは、この行の形状(0、)(2、)一緒にブロードキャストできませんでしたperms = getPermutations(array[:i] + array[i+1:])
RK1

@ RK1入力は何でしたか?
David Refaeli

私はnumpy配列_> を渡してgetPermutations(np.array([1, 2, 3]))いますが、リストで機能することがわかります。funcargが次のように混乱しただけですarray:)
RK1

@ RK1うまくいくと思います:-) listはpythonのキーワードです。そのため、パラメータを「シャドウ」するため、パラメータをキーワードと呼ぶことは通常お勧めできません。だから私は単語配列を使用します。これは私が使用しているリストの実際の機能です-配列のような方法です。ドキュメンテーションを書くなら、それを明確にすると思います。また、基本的な「インタビュー」の質問は、numpyのような外部パッケージなしで解決できると思います。
David Refaeli

それは本当だ、ええ、それを使ってしようとしてnumbaスピードに貪欲だったので、numpyアレイでのみそれを使用しようとした
RK1

4

パフォーマンスのために、Knuthに触発された派手なソリューション(p22):

from numpy import empty, uint8
from math import factorial

def perms(n):
    f = 1
    p = empty((2*n-1, factorial(n)), uint8)
    for i in range(n):
        p[i, :f] = i
        p[i+1:2*i+1, :f] = p[:i, :f]  # constitution de blocs
        for j in range(i):
            p[:i+1, f*(j+1):f*(j+2)] = p[j+1:j+i+2, :f]  # copie de blocs
        f = f*(i+1)
    return p[:n, :]

大量のメモリブロックをコピーすると、時間を節約できます。 list(itertools.permutations(range(n))

In [1]: %timeit -n10 list(permutations(range(10)))
10 loops, best of 3: 815 ms per loop

In [2]: %timeit -n100 perms(10) 
100 loops, best of 3: 40 ms per loop

3
from __future__ import print_function

def perm(n):
    p = []
    for i in range(0,n+1):
        p.append(i)
    while True:
        for i in range(1,n+1):
            print(p[i], end=' ')
        print("")
        i = n - 1
        found = 0
        while (not found and i>0):
            if p[i]<p[i+1]:
                found = 1
            else:
                i = i - 1
        k = n
        while p[i]>p[k]:
            k = k - 1
        aux = p[i]
        p[i] = p[k]
        p[k] = aux
        for j in range(1,(n-i)/2+1):
            aux = p[i+j]
            p[i+j] = p[n-j+1]
            p[n-j+1] = aux
        if not found:
            break

perm(5)

3

https://stackoverflow.com/a/108651/184528の Berのソリューションと同様に、新しい中間リストを作成せずにリストで機能するアルゴリズムを次に示します

def permute(xs, low=0):
    if low + 1 >= len(xs):
        yield xs
    else:
        for p in permute(xs, low + 1):
            yield p        
        for i in range(low + 1, len(xs)):        
            xs[low], xs[i] = xs[i], xs[low]
            for p in permute(xs, low + 1):
                yield p        
            xs[low], xs[i] = xs[i], xs[low]

for p in permute([1, 2, 3, 4]):
    print p

ここで自分でコードを試すことができます:http : //repl.it/J9v


3

再帰の美しさ:

>>> import copy
>>> def perm(prefix,rest):
...      for e in rest:
...              new_rest=copy.copy(rest)
...              new_prefix=copy.copy(prefix)
...              new_prefix.append(e)
...              new_rest.remove(e)
...              if len(new_rest) == 0:
...                      print new_prefix + new_rest
...                      continue
...              perm(new_prefix,new_rest)
... 
>>> perm([],['a','b','c','d'])
['a', 'b', 'c', 'd']
['a', 'b', 'd', 'c']
['a', 'c', 'b', 'd']
['a', 'c', 'd', 'b']
['a', 'd', 'b', 'c']
['a', 'd', 'c', 'b']
['b', 'a', 'c', 'd']
['b', 'a', 'd', 'c']
['b', 'c', 'a', 'd']
['b', 'c', 'd', 'a']
['b', 'd', 'a', 'c']
['b', 'd', 'c', 'a']
['c', 'a', 'b', 'd']
['c', 'a', 'd', 'b']
['c', 'b', 'a', 'd']
['c', 'b', 'd', 'a']
['c', 'd', 'a', 'b']
['c', 'd', 'b', 'a']
['d', 'a', 'b', 'c']
['d', 'a', 'c', 'b']
['d', 'b', 'a', 'c']
['d', 'b', 'c', 'a']
['d', 'c', 'a', 'b']
['d', 'c', 'b', 'a']

3

このアルゴリズムは最も効果的なアルゴリズムであり、再帰呼び出しでの配列の受け渡しと操作を回避し、Python 2、3で機能します。

def permute(items):
    length = len(items)
    def inner(ix=[]):
        do_yield = len(ix) == length - 1
        for i in range(0, length):
            if i in ix: #avoid duplicates
                continue
            if do_yield:
                yield tuple([items[y] for y in ix + [i]])
            else:
                for p in inner(ix + [i]):
                    yield p
    return inner()

使用法:

for p in permute((1,2,3)):
    print(p)

(1, 2, 3)
(1, 3, 2)
(2, 1, 3)
(2, 3, 1)
(3, 1, 2)
(3, 2, 1)

3
def pzip(c, seq):
    result = []
    for item in seq:
        for i in range(len(item)+1):
            result.append(item[i:]+c+item[:i])
    return result


def perm(line):
    seq = [c for c in line]
    if len(seq) <=1 :
        return seq
    else:
        return pzip(seq[0], perm(seq[1:]))

3

別のアプローチ(ライブラリなし)

def permutation(input):
    if len(input) == 1:
        return input if isinstance(input, list) else [input]

    result = []
    for i in range(len(input)):
        first = input[i]
        rest = input[:i] + input[i + 1:]
        rest_permutation = permutation(rest)
        for p in rest_permutation:
            result.append(first + p)
    return result

入力は文字列またはリストです

print(permutation('abcd'))
print(permutation(['a', 'b', 'c', 'd']))

これは整数のリストでは機能しません。[1, 2, 3]戻り値[6, 6, 6, 6, 6, 6]
RK1

@ RK1、print(permutation(['1','2','3']))
Tatsu

おかげで機能します
RK1

3

免責事項:パッケージ作成者による無形プラグ。:)

トロッターそれが示すように、実際の順列を含んではなく、順序に並べ替えとそれぞれの位置の間のマッピングを記述し、順列の非常に大規模な「リスト」で作業することが可能となっていない擬似リストを生成するには、パッケージはほとんどの実装は異なっていますで、このデモいる典型的なWebページよりも多くのメモリや処理を使用せずに、アルファベットの文字のすべての順列を「含む」を行い、擬似リストではかなり瞬間操作とルックアップを。

いずれの場合でも、順列のリストを生成するには、次のようにします。

import trotter

my_permutations = trotter.Permutations(3, [1, 2, 3])

print(my_permutations)

for p in my_permutations:
    print(p)

出力:

[1、2、3]の6つの3順列を含む疑似リスト。
[1、2、3]
[1、3、2]
[3、1、2]
[3、2、1]
[2、3、1]
[2、1、3]

2

可能なすべての順列を生成する

私はpython3.4を使用しています:

def calcperm(arr, size):
    result = set([()])
    for dummy_idx in range(size):
        temp = set()
        for dummy_lst in result:
            for dummy_outcome in arr:
                if dummy_outcome not in dummy_lst:
                    new_seq = list(dummy_lst)
                    new_seq.append(dummy_outcome)
                    temp.add(tuple(new_seq))
        result = temp
    return result

テストケース:

lst = [1, 2, 3, 4]
#lst = ["yellow", "magenta", "white", "blue"]
seq = 2
final = calcperm(lst, seq)
print(len(final))
print(final)

2

検索と実験にかかる時間を節約するために、Numbaでも動作するPythonの非再帰的順列ソリューションを示します(v。0.41以降)。

@numba.njit()
def permutations(A, k):
    r = [[i for i in range(0)]]
    for i in range(k):
        r = [[a] + b for a in A for b in r if (a in b)==False]
    return r
permutations([1,2,3],3)
[[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]]

パフォーマンスについての印象を与えるには:

%timeit permutations(np.arange(5),5)

243 µs ± 11.1 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)
time: 406 ms

%timeit list(itertools.permutations(np.arange(5),5))
15.9 µs ± 8.61 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
time: 12.9 s

したがって、このバージョンは、njitted関数から呼び出す必要がある場合にのみ使用してください。それ以外の場合は、itertools実装を優先してください。


1

純粋な再帰ではなく、これらの再帰関数の内部で多くの反復が行われているのがわかります...

したがって、単一のループでさえも従うことができないあなたのために、これは全体的で完全に不必要な完全に再帰的な解決策です

def all_insert(x, e, i=0):
    return [x[0:i]+[e]+x[i:]] + all_insert(x,e,i+1) if i<len(x)+1 else []

def for_each(X, e):
    return all_insert(X[0], e) + for_each(X[1:],e) if X else []

def permute(x):
    return [x] if len(x) < 2 else for_each( permute(x[1:]) , x[0])


perms = permute([1,2,3])

1

別の解決策:

def permutation(flag, k =1 ):
    N = len(flag)
    for i in xrange(0, N):
        if flag[i] != 0:
            continue
        flag[i] = k 
        if k == N:
            print flag
        permutation(flag, k+1)
        flag[i] = 0

permutation([0, 0, 0])

0

私のPythonソリューション:

def permutes(input,offset):
    if( len(input) == offset ):
        return [''.join(input)]

    result=[]        
    for i in range( offset, len(input) ):
         input[offset], input[i] = input[i], input[offset]
         result = result + permutes(input,offset+1)
         input[offset], input[i] = input[i], input[offset]
    return result

# input is a "string"
# return value is a list of strings
def permutations(input):
    return permutes( list(input), 0 )

# Main Program
print( permutations("wxyz") )

0
def permutation(word, first_char=None):
    if word == None or len(word) == 0: return []
    if len(word) == 1: return [word]

    result = []
    first_char = word[0]
    for sub_word in permutation(word[1:], first_char):
        result += insert(first_char, sub_word)
    return sorted(result)

def insert(ch, sub_word):
    arr = [ch + sub_word]
    for i in range(len(sub_word)):
        arr.append(sub_word[i:] + ch + sub_word[:i])
    return arr


assert permutation(None) == []
assert permutation('') == []
assert permutation('1')  == ['1']
assert permutation('12') == ['12', '21']

print permutation('abc')

出力:['abc'、 'acb'、 'bac'、 'bca'、 'cab'、 'cba']


0

使用する Counter

from collections import Counter

def permutations(nums):
    ans = [[]]
    cache = Counter(nums)

    for idx, x in enumerate(nums):
        result = []
        for items in ans:
            cache1 = Counter(items)
            for id, n in enumerate(nums):
                if cache[n] != cache1[n] and items + [n] not in result:
                    result.append(items + [n])

        ans = result
    return ans
permutations([1, 2, 2])
> [[1, 2, 2], [2, 1, 2], [2, 2, 1]]
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.