Écrivez une fonction qui prend en entrée un ensemble d'entiers (peut être une liste, un tableau ou tout autre conteneur avec des nombres distincts), et génère la liste de toutes ses permutations.
Python (95 caractères) :
p=lambda s:s and sum(map(lambda e:map(lambda p:[e]+p,p(filter(lambda x:x!=e,s))),s),[]) or [[]]Ce serait bien d'être battu dans la même langue, mais les implémentations dans d'autres langues sont plus que bienvenues!
Réponses:
L'entrée est un ensemble. La sortie est une liste de listes.
f=lambda a:[p+[x]for x in a for p in f(a-{x})]or[[]]
C'est plus court que la réponse qui fait tout le travail avec une fonction intégrée .
(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
Explication:
i.@!@# utilise trois verbes pour renvoyer une liste de 0 à (! n) -1 où n est le nombre d'éléments dans la liste donnée.
[renvoie la liste elle-même. Dans l'exemple illustré qui donne 0 1 2 3 4 5 A. 1 3 5.
A.renvoie une permutation possible de la deuxième liste pour chaque élément de la première liste (sorte de - l'explication appropriée est donnée ici ).
from itertools import*
p=lambda x:list(permutations(x))
p[]=[[]]
p l=[e:r|e<-l,r<-p$filter(/=e)l]
Essentiellement la même que la solution d'Ugoren, mais Haskell est meilleur dans la compréhension des listes!
import Data.List
p=permutations
import Data.List
p[]=[[]]
p l=(\(l,(e:r))->map(e:)$p(l++r))=<<(init$zip(inits l)(tails l))
Par conséquent, celui-ci fonctionne également lorsqu'il y a des éléments en double dans la liste.
p=Data.List.permutations. Cela ressemble à de la triche, cependant. De plus, Data.List.permutationsne produit pas les permutations dans l'ordre lexicographique.
p[]=[[]]comme cas de base à la place, en économisant deux octets.
f=->x{p *x.permutation}par exemple, f[[1,2,3]] émet ceci .
mais utiliser [].permutation, c'est comme tricher, donc:
f=->a{a.size<2?[a]:a.flat_map{|x|f[(a-x=[x])].map{|y|x+y}}}testé avec
100.times.all?{arr=(1..99).to_a.sample(rand(5)); arr.permutation.to_a==f[arr]}
=> truef(array) { return array.sort(); }
Python - 58 caractères
Légèrement plus court que celui d'Ugoren, en prenant un ensemble en entrée:
p=lambda x:x and[[y]+l for y in x for l in p(x-{y})]or[[]]
#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;}
La fonction P (n, a) renvoie un pointeur sur le n! permutations d'un, emballés les uns après les autres dans un tableau géant.
<malloc.h> isn't needed (ignore the warnings). sizeof n` est 4 (la portabilité est agréable, mais plus courte est plus agréable). Utilisez des paramètres supplémentaires comme variables (par exemple p(n,a,N,i)). int*p(..)int*a,o;. L'utilisation de variables globales au lieu de paramètres et de valeurs de retour est souvent utile.
{x@v@&((#x;1)~^=:)'v:!(#x)##x}
Pas de builtins!
def p(s:Seq[_])=s.permutations
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)
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)
import itertools
list(itertools.permutations("123"))
L.pb
Oui, Pyth a été créé après la publication de ce défi et tout. C'est encore vraiment cool. :RÉ
La lecture depuis stdin est un octet plus court:
.pQ
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>js function p(s,a="",c="",i,z=[]){ au lieu de js function p(s,a,c,i,z){if(!z)a=c="",z=[]
from itertools import*;lambda x:list(permutations(x))
Solution
prm
Explication:
Il s'agit d'un raccourci intégré de 3 octets vers la fonction intégrée de 47 octets suivante:
{[x]{[x]$[x;,/x ,''o'x ^/:x;,x]}@$[-8>@x;!x;x]}
... qui peut être raccourci à 23 octets si nous savons que nous obtenons une liste d'entiers en entrée:
{$[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)
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)
non golfé
--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
Tout cela appelle une fonction de bibliothèque qui donne une permutation sur l'index (uniquement des entiers comme permutation comme permutations sur [1], permutations sur [1,2], permutations sur [1,2,3] etc.). des indices et construire les listes; Il faut noter que cela semble être bien compilé pour chaque liste de 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
á
Cela a été heurté et n'a pas eu de réponse Japt, alors j'ai pensé que j'irais de l'avant et j'en ajouterais une. álorsqu'il est appliqué à un tableau et sans aucun argument, c'est la fonction intégrée pour "obtenir toutes les permutations". L' -Rindicateur utilisé dans le lien interprète modifie uniquement la façon dont le résultat est imprimé.
{1≥k←≢w←,⍵:⊂w⋄↑,/{w[⍵],¨q w[a∼⍵]}¨a←⍳k}
tester:
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
œ
L'entrée doit être un tableau / liste.
Explication:
œ //Takes all the permutations of the elements in the top of the stack (the input is a list, so it would work)
Un octet enregistré grâce à Erik l'Outgolfer