Tâche

Votre objectif, si vous l'acceptez, est d'écrire un programme qui, étant donné une chaîne d'entrée (ou un tableau de caractères), génère toutes les permutations possibles des lettres de cette chaîne. Je suis tatillon avec ma sortie, donc elle doit être triée par ordre alphabétique, sans doublons.

Exemple:

Contribution: buzz

Sortie:

buzz
bzuz
bzzu
ubzz
uzbz
uzzb
zbuz
zbzu
zubz
zuzb
zzbu
zzub

Règles

• C'est le code-golf donc le code le plus court l'emporte.
• Les espaces de fin sur chaque ligne / n'importe quelle ligne sont corrects
• Une seule nouvelle ligne après la dernière ligne est autorisée (mais pas plus)

Gelée , 5 octets

ṢŒ!QY

Essayez-le en ligne!

Explication

Ṣ         Sort
 Œ!       All permutations
   Q      Unique
    Y     Join by linefeeds

05AB1E ,  4  3 octets

Mise à jour, depuis une mise à jour pour œcasser l'ancienne version,
qui a également enregistré un octet comme suggéré par Magic Octopus Urn .

œê»

Essayez-le en ligne!

Explication

œ     # get all permutations of input
 ê    # sort and remove duplicates
  »   # join list by newlines

MATL , 4 octets

Y@Xu

Essayez-le en ligne!

Explication

Y@    % Implicit input. Push 2D array of all permutations, each on a row, sorted
Xu    % Unique rows. Implicitly display

Python 3.5, 79 octets

def f(s,w=''):
 s or print(w)
 for c in sorted({*s}):t=s*1;t.remove(c);f(t,w+c)

Une fonction qui prend en entrée une liste de caractères et sort par impression.

Effectue récursivement chaque permutation distincte en retirant alphabétiquement chaque caractère suivant possible des caractères distincts restants et en l'ajoutant à la sortie en cours w. Ensuite, nous récursions avec ce personnage supprimé. Une fois l'entrée vide, nous imprimons w.

CJam , 5 octets

Merci à @EriktheOutgolfer pour une correction ( qau lieu de r)

qe!N*

Essayez-le en ligne!

Explication

q        e# Read input as a string
 e!      e# Unique permutations, sorted
   N*    e# Join by newline. Implicitly display

Pyth - 5 octets

jS{.p

Essayez-le en ligne ici .

j        Join. Implictly joins on newlines.
 S       Sort
  {      Uniquify
   .p    All permutations, implicitly run on input.

Haskell, 46 octets

import Data.List;unlines.sort.nub.permutations

2 octets économisés grâce à nimi

J, 19 octets

/:~@~.@:{~!@#A.&i.#

Cas de test

   f =: /:~@~.@:{~!@#A.&i.#
   f 'buzz'
buzz
bzuz
bzzu
ubzz
uzbz
uzzb
zbuz
zbzu
zubz
zuzb
zzbu
zzub

Explication

Il s'agit d'un 4 trains:

                     /- ~ --- /:
               /- @ -^- ~.
  /- ~ --- @: -^- {
  |
  |            /- !
--<     /- @ --^- #
  |     |
  \-----<      /- A.
        >- & --^- i.
        \- #

Fondamentalement:

/:~@~.@:{~!@#A.&i.#
          !  A.&     get permutations
           @#   i.#  of range (0..length)
        {~           map indices to chars in string
      @:             then
    ~.               unique
   @                 then
/:~                  sort

JavaScript (Firefox 30+), 129 124 octets

f=(a,i=-1)=>a[1]?[for(x of a.sort())if(a.indexOf(x)==++i)f([...a.slice(0,i),...a.slice(i+1)]).replace(/^/gm,x)].join`
`:a[0]

Pas trop mal pour une langue sans permutation intégrée ...

Python 3.5, 81 octets:

from itertools import*;lambda i:'\n'.join(sorted({*map(''.join,permutations(i))}))

Vraiment ... 81 octets lorsque la prochaine réponse la plus longue est de 48 octets ... soupir . Eh bien, je vais essayer ce golf autant que possible, mais les conseils de golf sont toujours très appréciés.

En outre, voici la solution la plus courte que j'ai pu obtenir en Python 2 à 86 octets :

from itertools import*;lambda f:'\n'.join(sorted({''.join(i)for i in permutations(f)}))

Apparemment en Python 2, [*...]retourne un Syntax Error, et depuis permutationsretourne itertools.permutations object at 0x..., la prochaine façon la plus courte (que je connaisse) d'extraire les permutations uniques utilise {''.join(i)for i in permutations(f)}où fest la chaîne d'entrée.

Enfin, notez que ce sont deux fonctions lambda et doivent donc être appelées dans le format print(<Function Name>(<Input String>)).

Mathematica, 34 23 octets

Print@@@Permutations@#&

L'entrée doit être une liste de caractères.

Explication

Permutations@

Trouvez toutes les permutations de l'entrée, triées et sans doublon.

Print@@@

Imprimez-les un par un.

Brachylog , 9 octets

:pfdo~@nw

Essayez-le en ligne!

Explication

:pf         Find all outputs of p - Permute with the main Input as input
   d        Remove Duplicates
    o       Order
     ~@n    Concatenate into a single string with linebreaks as separator
        w   Write to STDOUT

Perl 6 ,  49  44 octets

Chaîne en entrée

*.comb.permutations.sort».join.squish.map: *.put

Liste des caractères en entrée

*.permutations.sort».join.squish.map: *.put

Étendu

*\              # Whatever lambda
# .comb\        # split into a list of characters
.permutations\  # returns a list of lists
.sort\
».join\         # join the second level lists
.squish\        # remove adjacent repeated values
.map: *.put     # print each on its own line

Brachylog (v2), 5 octets

pᵘoẉᵐ

Essayez-le en ligne!

Trouver ᵘnique permutations d'entrée, s oles rt, ᵐap ẉriteln (écriture avec saut de ligne) sur ce tableau.

Python 3, 77 85 octets

Maintenant, trie!

import itertools as i
for a in sorted(set(i.permutations(input()))):print("".join(a))

PowerShell v3 +, 171 octets

param([char[]]$x)$a,$b=$x;$a=,$a;while($b){$z,$b=$b;$a+=$a|%{0..($y=($c="$_").Length)|%{-join($c[0..$_]+$z+$c[++$_..$y])};"$z$c";"$c$z"}}$a|?{$_.length-eq$x.count}|sort -u

PowerShell v3 a introduit le -Uniquedrapeau sur leSort-Object applet de commande, il est donc plus court de quelques octets que la version v2 ci-dessous, car nous n'avons pas besoin de Selectcommencer.

version v2, 178 octets:

param([char[]]$x)$a,$b=$x;$a=,$a;while($b){$z,$b=$b;$a+=$a|%{0..($y=($c="$_").Length)|%{-join($c[0..$_]+$z+$c[++$_..$y])};"$z$c";"$c$z"}}$a|?{$_.length-eq$x.count}|select -u|sort

PowerShell n'a pas de permutations intégrées, j'ai donc emprunté mon code à Prime Factors Buddies et l' ai légèrement modifié pour l'utiliser ici.

Il s'agit essentiellement de trois parties, que je développerai ci-dessous.

param([char[]]$x)$a,$b=$x;$a=,$aPrend l'entrée $x, la chartransforme en tableau, supprime la première lettre $aet le reste $b, puis la refonte $asous forme de tableau avec l'opérateur virgule.

while($b){$z,$b=$b;$a+=$a|%{0..($y=($c="$_").Length)|%{-join($c[0..$_]+$z+$c[++$_..$y])};"$z$c";"$c$z"}}Boucle à travers les lettres restantes ( $b), chaque itération prenant la lettre suivante et la stockant dans $zet en laissant le reste $b, puis concaténant le tableau sur $ale résultat de l'envoi $avia sa propre boucle - chaque élément de $a(temporairement stocké dans $c) est bouclé son propre .length, puis $zest inséré dans chaque position, y compris pré-ajout et ajout avec $z$cet $c$z. Par exemple, pour $c = '12'et $z = '3', cela se traduira par '132','312','123'une nouvelle concaténation dans $a.

La dernière partie $a|?{$_.length-eq$x.count}|select -u|sortprend chaque élément $aet utilise la Where-Objectclause pour filtrer uniquement ceux qui ont la même longueur que la chaîne d'entrée, puis selects uniquement les -uéléments niques et enfin sorts ceux par ordre alphabétique. Les chaînes résultantes sont toutes laissées sur le pipeline, et la sortie via implicite Write-Outputse produit à la fin du programme.

PS C:\Tools\Scripts\golfing> .\alphabetically-permute-a-string.ps1 'PPCG'
CGPP
CPGP
CPPG
GCPP
GPCP
GPPC
PCGP
PCPG
PGCP
PGPC
PPCG
PPGC

JavaScript (ES6), 119 octets

f=(s,t=[...s].sort().join``,p=``)=>t?t.replace(/./g,(c,i)=>t.indexOf(c)==i?f(s,t.slice(0,i)+t.slice(i+1),p+c):``):p+`\n`

Où \nreprésente le caractère de nouvelle ligne littéral. Port de la réponse de @ ETHproduction pour utiliser des chaînes au lieu de tableaux. Inverser la sortie, ou déplacer le retour à la ligne au début, économise 3 octets.

R, 113 octets

x=scan(,"");cat(sort(unique(apply(matrix(x[permute:::allPerms(l<-length(x))],,l),1,paste,collapse=""))),sep="\n")

Lit l'entrée de stdin. Le permutepackage est supposé être installé afin d'appeler leallPerms fonction.

Ajoutera une explication à mon retour du travail.

Java 302 300 octets

import java.util.*;class M{public static void main(String[]a){for(Object s:p(new TreeSet(),"",a[0]))System.out.println(s);}static Set p(Set l,String p,String s){int n=s.length(),i=0;if(n>1)for(;i<n;p(l,p+s.charAt(i),s.substring(0,i)+s.substring(++i,n)));else if(!l.contains(p+=s))l.add(p);return l;}}

Code non testé et testé:

Essayez-le ici.

import java.util.*;
class M{
  static Set p(Set l, String p, String s){
    int n = s.length(),
        i = 0;
    if(n > 1){
      for(; i < n; p(l, p + s.charAt(i), s.substring(0, i) + s.substring(++i, n)));
    } else if(!l.contains(p+=s)){
      l.add(p);
    }
    return l;
  }

  public static void main(String[] a){
    for(Object s : p(new TreeSet(), "", a[0])){
      System.out.println(s);
    }
  }
}

Entrée: test
Sortie:

estt
etst
etts
sett
stet
stte
test
tets
tset
tste
ttes
ttse

Raquette 82 octets

(sort(remove-duplicates(map list->string(permutations(string->list s)))) string<?)

Non golfé:

(define(f s)
 (sort
  (remove-duplicates
   (map
    list->string
    (permutations
     (string->list s))))
  string<?))

Essai:

(f "buzz")

Sortie:

'("buzz" "bzuz" "bzzu" "ubzz" "uzbz" "uzzb" "zbuz" "zbzu" "zubz" "zuzb" "zzbu" "zzub")

Groovy, 69 octets

{(it as List).permutations().unique().sort().each{println it.join()}}

Rubis, 51 octets

->s{puts s.chars.permutation.map(&:join).uniq.sort}

En fait , 8 octets

Suggestions de golf bienvenues! Essayez-le en ligne!

;l@╨♂Σ╔i

Ungolfing

     Implicit input s.
;l   Get len(s).
@╨   Get all len(s)-length permutations of s.
♂Σ   Sum them all back into strings.
╔    uniq() the list of strings.
i    Flatten the list of strings.
     Implicit print the stack, separated by newlines.

Pip , 8 octets

7 octets de code, +1 pour l' -nindicateur.

SSUQPMa

Prend une chaîne comme argument de ligne de commande. Essayez-le en ligne!

Le scanner de Pip divise les séries de lettres majuscules en blocs de deux lettres. Donc, ce code est SS UQ PM a--ie SortString(UniQue(PerMutations(a))), avec al'argument de la ligne de commande. L' -nindicateur garantit que la liste des résultats est séparée par des sauts de ligne. C'est tout ce qu'on peut en dire.

K (oK) , 14 octets

Solution:

?x@<x@:prm@#x:

Essayez-le en ligne!

Explication:

Utilisez la fonction de permutation intégrée, prmpour générer des permutations de la longueur de l'entrée, appliquez ces permutations à l'entrée, triez par ordre alphabétique, puis prenez des valeurs distinctes.

?x@<x@:prm@#x: / the solution
            x: / store input as x
           #   / count length of x
       prm@    / apply (@) function prm
    x@:        / apply indices to x and save result back into x
   <           / indices to sort ascending
 x@            / apply to x
?              / take distint

Perl 5 -MList::Util=uniq -F , 68 octets

$"=',';@b=sort@F;map{say if"@b"eq join$",sort/./g}uniq glob"{@b}"x@b

Essayez-le en ligne!

Japt v2.0a0-R , 5 octets

á â n

Essayez-le

C ++ (gcc) , 132 128 octets

#include<bits/stdc++.h>
using namespace std;int main(){string s;for(cin>>s;cout<<s<<endl,next_permutation(s.begin(),s.end()););}

Essayez-le en ligne!

Palourde , 9 octets

p_D`Sq@~Q

Explication

          - Implicit Q = first input
p         - Print...
 _        - Sorted ascending value (alphabetical order)
  D       - Distinct from...
   `Sq    - Joined (map(q=>q.join(""))
      @~Q - Permutations of Q