정수 세트 (목록, 배열 또는 다른 숫자가있는 다른 컨테이너 일 수 있음)를 입력으로 받아서 모든 순열 목록을 출력하는 함수를 작성하십시오.

파이썬 (95 자) :

p=lambda s:s and sum(map(lambda e:map(lambda p:[e]+p,p(filter(lambda x:x!=e,s))),s),[]) or [[]]

같은 언어로 구타를하는 것은 좋지만 다른 언어로 구현하는 것은 환영합니다.

파이썬-76 자

gnibbler보다 길지만 처음부터 구현합니다.

p=lambda x:x and[[a]+b for a in x for b in p([c for c in x if c!=a])]or[[]]

파이썬, 52

입력이 세트입니다. 출력은 목록의 목록입니다.

f=lambda a:[p+[x]for x in a for p in f(a-{x})]or[[]]

이것은 모든 작업을 내장 하는 답변 보다 짧습니다 .

J, 11 자

(i.@!@#A.[)

용법:

   (i.@!@#A.[) 1 3 5
1 3 5
1 5 3
3 1 5
3 5 1
5 1 3
5 3 1

설명:

i.@!@# 3 개의 동사를 사용하여 0에서 (! n) -1까지의 목록을 반환합니다. 여기서 n은 주어진 목록의 항목 수입니다.

[리스트 자체를 돌려줍니다. 표시된 예에서는을 제공합니다 0 1 2 3 4 5 A. 1 3 5.

A.첫 번째 목록의 각 항목에 대해 두 번째 목록의 가능한 순열을 반환합니다 ( 여기 에서 적절한 설명이 제공 됩니다 ).

파이썬-55 자

from itertools import*
p=lambda x:list(permutations(x))

하스켈, _⁴⁴ 43

p[]=[[]]
p l=[e:r|e<-l,r<-p$filter(/=e)l]

본질적으로 ugoren의 솔루션과 동일하지만 Haskell이 목록 이해에 더 좋습니다!

30

import Data.List
p=permutations

92

import Data.List
p[]=[[]]
p l=(\(l,(e:r))->map(e:)$p(l++r))=<<(init$zip(inits l)(tails l))

결과적으로 목록에 중복 요소가있는 경우에도 작동합니다.

Q에서 (48)

g:{$[x=1;y;raze .z.s[x-1;y]{x,/:y except x}\:y]}

샘플 사용법 :

q)g[3;1 2 3]
1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1

루비-23 자

f=->x{p *x.permutation}

예를 들어 f[[1,2,3]] 이것을 출력합니다 .

하지만 사용하는 [].permutation것은 속임수처럼 느껴집니다.

루비-59 자

f=->a{a.size<2?[a]:a.flat_map{|x|f[(a-x=[x])].map{|y|x+y}}}

테스트

100.times.all?{arr=(1..99).to_a.sample(rand(5)); arr.permutation.to_a==f[arr]}
=> true

파이썬-58 자

입력으로 설정하여 우고 렌보다 약간 짧습니다.

p=lambda x:x and[[y]+l for y in x for l in p(x-{y})]or[[]]

기음, 270 243 239 자

#define S t=*a;*a=a[i];a[i]=t;
#define R o=p(n,r-1,a+1,o,r-2,0)
int*p(n,r,a,o,i,t)int*a,*o;{if(!r)for(;n;--n)*o++=*--a;else{R;for(;i;--i){S R;S}}return o;}
P(n,a)int*a;{int N=1,i=n;for(;i;N*=i--);return p(n,n,a,malloc(N*n*8),n-1,0)-N*n;}

함수 P (n, a)는 n에 대한 포인터를 반환합니다! 하나의 거대한 배열로 차례로 포장 된 a의 순열.

K, 30 바이트

{x@v@&((#x;1)~^=:)'v:!(#x)##x}

내장이 없습니다!

JS- 154 146 자

function f(x){var a=[],m;(m=x.length)>1?f(x.slice(1)).map(function(y){for(l=m;l--;a.push(y.slice(0,l).concat(x[0],y.slice(l))));}):a=[x];return a}

테스트 : 이것을f([1,2,3,4,5]).map(function(a){return a.join('')}).join('\n') 반환 합니다 .

아르 자형

순열에 대해 이야기하고 있으므로 R에서 하나 이상의 솔루션을 보여 드리겠습니다.

library(gtools);v=c(3,4,5);permutations(length(v),length(v),v)

펄 188

라이브러리 루틴, 재귀 없음

sub p{$l=(@_=sort split'',shift)-1;while(print@_){$k=$j=$l;--$k while($_[$k-1]cmp$_[$k])>=0;$k||last;--$j while($_[$k-1]cmp$_[$j])>=0;@_[$j,$k-1]=@_[$k-1,$j];@_[$k..$l]=reverse@_[$k..$l]}}

스칼라 30 :

def p(s:Seq[_])=s.permutations 

Scala 195, 라이브러리에서 순열 이 없는 더러워진

def c(x:Int,t:List[_]):List[_]={val l=t.size
val o=x%l
if(l>1){val r=c(x/l,t.tail)
r.take(o):::(t.head::r.drop(o))}else
t}
def p(y:List[_])=(0 to(1 to y.size).product).foreach(z=>println(c(z,y)))

val y=List(0,1,2,3)
p(y)

Scala 293, 완전 재배 형 안전 반복자 :

class P[A](val l:Seq[A])extends Iterator[Seq[A]]{
var c=0
val s=(1 to l.size).product
def g(c:Int,t:List[A]):List[A]={
val n=t.size
val o=c%n
if(n>1){val r=g(c/n,t.tail)
r.take(o):::(t.head::r.drop(o))
}else
t}
def hasNext=c!=s
def next={c+=1
g(c-1,l.toList)}
}
for(e<-new P("golf"))println(e)

파이썬-50 자

import itertools
list(itertools.permutations("123"))

Pyth, 4 바이트

L.pb

네, Pyth는이 ​​도전이 게시 된 후에 만들어졌습니다. 이것은 여전히 ​​정말 멋지다. :디

라이브 데모.

stdin에서 읽는 것이 바이트보다 짧습니다.

.pQ

자바 스크립트 143 136 134 123

function p(s,a="",c="",i,z=[]){a+=c,i=s.length
!i?z.push(a):0
for(;i--;s.splice(i,0,c))p(s,a,c=s.splice(i,1),0,z);return z}

var perms = p([1,2,3]);

document.getElementById('output').innerHTML = perms.join("\n");

<pre id="output"></pre>

Brachylog , 2 바이트

pᵘ

온라인으로 사용해보십시오!

 ᵘ    Find every unique
p     permutation of the input.

파이썬, 53 바이트

from itertools import*;lambda x:list(permutations(x))

젤리 , 2 바이트

Œ!

온라인으로 사용해보십시오!

내장에 대한 예!

K (oK) , 3 바이트

해결책

prm

온라인으로 사용해보십시오!

설명:

다음 내장 47 바이트 기능에 대한 3 바이트 내장 단축키입니다 .

{[x]{[x]$[x;,/x ,''o'x ^/:x;,x]}@$[-8>@x;!x;x]}

... 입력으로 정수 목록을 얻는다는 것을 알면 23 바이트로 단축 할 수 있습니다.

{$[x;,/x,''o'x^/:x;,x]} / golfed built in
{                     } / lambda function with implicit input x
 $[ ;             ;  ]  / if[condition;true;false]
   x                    / if x is not null...
             x^/:x      / x except (^) each-right (/:) x; create length-x combinations
           o'           / call self (o) with each of these
       x,''             / x concatenated with each-each of these results (this is kinda magic to me)
     ,/                 / flatten list
                    ,x  / otherwise enlist x (enlisted empty list)

공리, 160 바이트

p(a)==(#a=0=>[[]];r:=[[a.1]];r:=delete(r,1);n:=#a;m:=factorial n;m>1.E7=>r;b:=permutations n;for j in 1..m repeat(x:=b.j;r:=concat([a.(x.i)for i in 1..n],r));r)

언 골프

--Permutation of a
pmt(a)==
     #a=0=>[[]]
     r:=[[a.1]]; r:=delete(r,1) -- r has the type List List typeof(a)
     n:=#a
     m:=factorial n
     m>1.E7=>r
     b:=permutations(n)         --one built in for permutation indices 
     for j in 1..m repeat
        x:=b.j
        r:=concat([a.(x.i) for i in 1..n],r)
     r

이 모든 것은 인덱스에 대한 순열을 제공하는 하나의 라이브러리 함수를 호출합니다 ([1]에 대한 순열, [1,2]에 대한 순열, [1,2,3]에 대한 순열 등의 정수만 해당). 지수의 목록을 작성하고; 이것은 X 유형의 모든 List에 대해 잘 컴파일 된 것으로 보입니다.

(4) -> p([1,2,3])
   Compiling function p with type List PositiveInteger -> List List
      PositiveInteger
   (4)  [[1,2,3],[1,3,2],[3,1,2],[2,1,3],[2,3,1],[3,2,1]]
                                          Type: List List PositiveInteger
(5) -> p([x^2,y*x,y^2])
   Compiling function p with type List Polynomial Integer -> List List
      Polynomial Integer
   (5)
      2      2    2  2        2  2            2  2        2  2    2      2
   [[x ,x y,y ],[x ,y ,x y],[y ,x ,x y],[x y,x ,y ],[x y,y ,x ],[y ,x y,x ]]
                                       Type: List List Polynomial Integer
(6) -> p([sin(x),log(y)])
   Compiling function p with type List Expression Integer -> List List
      Expression Integer
   (6)  [[sin(x),log(y)],[log(y),sin(x)]]
                                       Type: List List Expression Integer
(7) -> m:=p("abc")::List List Character
   Compiling function p with type String -> Any
   (7)  [[a,b,c],[a,c,b],[c,a,b],[b,a,c],[b,c,a],[c,b,a]]
                                                Type: List List Character
(8) -> [concat(map(x+->x::String, m.j))  for j in 1..#m]
   (8)  ["abc","acb","cab","bac","bca","cba"]
                                                        Type: List String

Japt , 1 바이트

á

apt 통역

이것은 혼란스럽고 Japt 대답이 없었으므로 계속해서 추가 할 것이라고 생각했습니다. á배열에 적용되고 인수가없는 경우 "모든 순열 가져 오기"에 내장되어 있습니다. -R결과를 인쇄 할 경우에만 수정하는 방법 인터프리터 링크에 사용되는 플래그.

APL (NARS), 39 자, 78 바이트

{1≥k←≢w←,⍵:⊂w⋄↑,/{w[⍵],¨q w[a∼⍵]}¨a←⍳k}

테스트:

  q←{1≥k←≢w←,⍵:⊂w⋄↑,/{w[⍵],¨q w[a∼⍵]}¨a←⍳k}
  q 1 2 3
1 2 3  1 3 2  2 1 3  2 3 1  3 1 2  3 2 1 
  q 'abcd'
abcd abdc acbd acdb adbc adcb bacd badc bcad bcda bdac bdca cabd cadb cbad cbda cdab cdba dabc dacb dbac dbca dcab dcba 

05AB1E - 2 개 1 바이트 의

œ

입력은 배열 / 목록이어야합니다.

설명:

œ //Takes all the permutations of the elements in the top of the stack (the input is a list, so it would work)

Outgolfer Erik 덕분에 바이트 절약