[Question]
  [
Write a function that takes as input a set of integers (can be a list, array or any other container with distinct numbers), and outputs the list of all its permutations.
**Python (95 chars)**:
```
p=lambda s:s and sum(map(lambda e:map(lambda p:[e]+p,p(filter(lambda x:x!=e,s))),s),[]) or [[]]
```
It'd be nice to be beaten in the same language, but implementations in other languages are more than welcome!
  
[Answer]
# Python, 52
Input is a set. Output is a list of lists.
```
f=lambda a:[p+[x]for x in a for p in f(a-{x})]or[[]]
```
This is shorter than the [answer that does all the work with a builtin](https://codegolf.stackexchange.com/a/5057/30688).
[Answer]
## Python - 76 chars
Longer than gnibbler's, but implements things from scratch.
```
p=lambda x:x and[[a]+b for a in x for b in p([c for c in x if c!=a])]or[[]]
```
[Answer]
## J, 11 characters
```
(i.@!@#A.[)
```
Usage:
```
   (i.@!@#A.[) 1 3 5
1 3 5
1 5 3
3 1 5
3 5 1
5 1 3
5 3 1
```
Explanation:
`i.@!@#` uses three verbs to return a list from 0 to (!n)-1 where n is the number of items in the given list.
`[` returns the list itself. In the example shown that gives `0 1 2 3 4 5 A. 1 3 5`.
`A.` returns one possible permutation of the second list for each item in the first list (kind of - the proper explanation is given [here](http://www.jsoftware.com/help/dictionary/dacapdot.htm)).
[Answer]
## Python - 55 chars
```
from itertools import*
p=lambda x:list(permutations(x))
```
[Answer]
## Haskell, 44 43
```
p[]=[[]]
p l=[e:r|e<-l,r<-p$filter(/=e)l]
```
Essentially the same as ugoren's solution, but Haskell is better at list comprehensions!
---
Of course, it can also do
## 30
```
import Data.List
p=permutations
```
---
More efficient approach, that doesn't require an equality comparison:
## 92
```
import Data.List
p[]=[[]]
p l=(\(l,(e:r))->map(e:)$p(l++r))=<<(init$zip(inits l)(tails l))
```
As a consequece, this one also works when there are duplicate elements in the list.
[Answer]
# C, ~~270~~ ~~243~~ 239 characters
```
#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;}
```
The function P(n,a) returns a pointer to the n! permutations of a, packed one after another in one giant array.
[Answer]
# [Prolog (SWI)](http://www.swi-prolog.org), 33 bytes
```
X-Y:-bagof(A,permutation(X,A),Y).
```
[Try it online!](https://tio.run/##KyjKz8lP1y0uz/z/P0I30ko3KTE9P03DUacgtSi3tCSxJDM/TyNCx1FTJ1JT77@9rkK0oY6RjnGsbqSOQnlRZklqTp4GSAYA "Prolog (SWI) – Try It Online")
-2 from steffan
[Answer]
## in Q (48)
```
g:{$[x=1;y;raze .z.s[x-1;y]{x,/:y except x}\:y]}
```
Sample usage:
```
q)g[3;1 2 3]
1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1
```
[Answer]
# Ruby - 23 chars
```
f=->x{p *x.permutation}
```
for example `f[[1,2,3]]` [outputs this](http://pastebin.com/sx9aNEVk).
but using `[].permutation` feels like cheating, so:
# Ruby - 59 chars
```
f=->a{a.size<2?[a]:a.flat_map{|x|f[(a-x=[x])].map{|y|x+y}}}
```
tested with
```
100.times.all?{arr=(1..99).to_a.sample(rand(5)); arr.permutation.to_a==f[arr]}
=> true
```
[Answer]
### Scala 30:
```
def p(s:Seq[_])=s.permutations 
```
### Scala 195, quick'n'dirty, without *permutations* from library:
```
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, full grown, type safe iterator:
```
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)
```
[Answer]
**Python - 58 chars** 
Slightly shorter than ugoren's, by taking a set as input:
```
p=lambda x:x and[[y]+l for y in x for l in p(x-{y})]or[[]]
```
[Answer]
# K, 30 bytes
```
{x@v@&((#x;1)~^=:)'v:!(#x)##x}
```
No builtins!
[Answer]
## JS - ~~154~~ 146 chars
`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}`
Test : `f([1,2,3,4,5]).map(function(a){return a.join('')}).join('\n')` returns [this](http://pastebin.com/8Wu0q7r3).
[Answer]
## R
Since we are talking about permutations let me show at least one solution in R:
```
library(gtools);v=c(3,4,5);permutations(length(v),length(v),v)
```
[Answer]
## Perl 188
No library routines, no recursion
```
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]}}
```
[Answer]
## Python - 50 chars
```
import itertools
list(itertools.permutations("123"))
```
[Answer]
# Pyth, 4 bytes
```
L.pb
```
Yeah, Pyth was created after this challenge was posted and all. This is still really cool. :D
[Live demo.](https://pyth.herokuapp.com/?code=L.pb%0Ay%5B1+2+3%29&debug=1)
Reading from stdin is a byte shorter:
```
.pQ
```
[Answer]
# JavaScript ~~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>
```
[Answer]
# 05AB1E - 2 1 bytes
`œ`
The input must be an array/list.
Explanation:
```
œ //Takes all the permutations of the elements in the top of the stack (the input is a list, so it would work)
```
Saved a byte thanks to Erik the Outgolfer
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 2 bytes
```
pᵘ
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/r/qG3Do6bGh1snlP8veLh1xv//0dGGOkY6xjomOqaxOtFmOiZGQMpAx9BIJ97YODYWAA "Brachylog – Try It Online")
```
 ᵘ    Find every unique
p     permutation of the input.
```
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal), 2 bytes
```
ṖU
```
[Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%E1%B9%96U&inputs=%5B1%2C1%2C3%5D&header=&footer=)
```
Ṗ  # All permutations of input 
 U # Filtered by unique
```
[Answer]
# JavaScript (ES6), ~~91~~ 78 bytes
*-5 thanks to @Neil*
```
f=a=>a.length<2?[a]:a.flatMap((x,i)=>f(a.filter((_,j)=>i-j)).map(t=>[x,...t]))
```
Pretty normal recursive approach, and my first time using `copyWithin` :p
Okay, `copyWithin` modifies the array, so that doesn't work. Used a different approach, which now saves more bytes.
[Answer]
# Curry, ~~41~~ 26 bytes
*15 bytes saved by alephalpha*
*Tested in [PAKCS](https://www.informatik.uni-kiel.de/%7Epakcs/)*
```
p[]=[]
p(x++a:y)=a:p(x++y)
```
[Try it online!](https://tio.run/##Sy4tKqrULUjMTi7@/78gOtY2OparQKNCWzvRqlLTNtEKzK7U/J@bmJmnYKtQoBBtrGOiY6hjFPsfAA "Curry (PAKCS) – Try It Online")
Uses non-determinism to output all the permutations. This same code is used in my answer [here](https://codegolf.stackexchange.com/a/246041/) for which I originally wrote it.
[Answer]
# [Knight](https://github.com/knight-lang/knight-lang), 180 bytes
```
;=i=jF;W=pP E++"=x"=i+1i" p";=s"";W>i-=j+1jT=s+++++++s";=y"j"F W>i-=y"j"+1y"j"T"E+s';=z=bF;W>i-=z+1zT;=aF W>i-=a+1aT|?z a=b|b?E+"y"zE+"y"a|b;=rF;=s"";W>z=r+1r=s++sE+"x"E+"y"r" "Os'
```
[Try it online!](https://knight-lang.netlify.app/#WyI7PWk9akY7Vz1wUCBFKytcIj14XCI9aSsxaVwiIHBcIjs9c1wiXCI7Vz5pLT1qKzFqVD1zKysrKysrK3NcIjs9eVwialwiRiBXPmktPXlcImpcIisxeVwialwiVFwiRStzJzs9ej1iRjtXPmktPXorMXpUOz1hRiBXPmktPWErMWFUfD96IGE9YnxiP0UrXCJ5XCJ6RStcInlcImF8Yjs9ckY7PXNcIlwiO1c+ej1yKzFyPXMrK3NFK1wieFwiRStcInlcInJcIiBcIk9zJyIsIjJcbjRcbjZcbjgiXQ==)
This was a *pain*. Nested evals and stuff. Since recursion doesn't really work, I had to literally compose a string of nested while loops, and then eval it. Extremely inefficient, \$O(n^{n+1})\$ where \$n\$ is the length of the input. My browser started to freeze up with \$n=6\$.
-2 bytes thanks to Aiden Chow.
[Answer]
# Python, 53 bytes
```
from itertools import*;lambda x:list(permutations(x))
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 2 bytes
```
Œ!
```
[Try it online!](https://tio.run/##y0rNyan8///oJMX/h9sj//9XKkktLlECAA "Jelly – Try It Online")
Yay for builtins!
[Answer]
# [K (oK)](https://github.com/JohnEarnest/ok), 3 bytes
**Solution**
```
prm
```
[Try it online!](https://tio.run/##y9bNz/7/v6AoV8FQwUjBWMHk/38A "K (oK) – Try It Online")
**Explanation:**
It's a 3 byte **built-in** shortcut to the following **built-in** 47 byte function:
```
{[x]{[x]$[x;,/x ,''o'x ^/:x;,x]}@$[-8>@x;!x;x]}
```
... which can be shortened to 23 bytes if we know we're getting a list of ints as input:
```
{$[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)
```
[Answer]
# Axiom, 160 bytes
```
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)
```
ungolfed
```
--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
```
All this call one library function that give permutation on index (only integers as permutation as permutations on [1], permutations on [1,2], permutations on[1,2,3] etc).So it is enough get these set of indices and build the lists; One has to note that this seems to be compiled good for every List of type X
```
(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
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 1 byte
```
á
```
[Japt interpreter](https://ethproductions.github.io/japt/?v=1.4.6&code=4Q==&input=WzAsMSwyLDMsNF0KLVI=)
This got bumped and didn't have a Japt answer, so I figured I'd go ahead and add one. `á` when applied to an array and without any arguments is the builtin for "get all permutations". The `-R` flag used in the interpreter link only modifies how the result is printed.
[Answer]
# APL(NARS), 39 chars, 78 bytes
```
{1≥k←≢w←,⍵:⊂w⋄↑,/{w[⍵],¨q w[a∼⍵]}¨a←⍳k}
```
test:
```
  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 
```
]