Tarea

Su objetivo, si elige aceptarlo, es escribir un programa que, dada una cadena de entrada (o conjunto de caracteres), produzca todas las permutaciones posibles de las letras en esa cadena. Soy quisquilloso con mi salida, por lo que debe ordenarse alfabéticamente, sin duplicados.

Ejemplo:

Entrada: buzz

Salida:

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

Reglas

• Este es el código de golf, por lo que gana el código más corto.
• Los espacios finales en cada / cualquier línea están bien
• Se permite una nueva línea después de la última línea (pero no más)

Jalea , 5 bytes

ṢŒ!QY

Pruébalo en línea!

Explicación

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

05AB1E ,  4  3 bytes

Actualizado, desde una actualización para œromper la versión anterior,
que también salvó un byte como lo sugiere Magic Octopus Urn .

œê»

Pruébalo en línea!

Explicación

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

MATL , 4 bytes

Y@Xu

Pruébalo en línea!

Explicación

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

Python 3.5, 79 bytes

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

Una función que toma entrada como una lista de caracteres y salidas imprimiendo.

Realiza recursivamente cada permutación distinta al tomar alfabéticamente cada uno de los siguientes caracteres posibles de los caracteres distintos restantes y agregarlos a la salida en progreso w. Luego, recurrimos con este personaje eliminado. Una vez que se vacía la entrada, imprimimos w.

CJam , 5 bytes

Gracias a @EriktheOutgolfer por una corrección (en qlugar de r)

qe!N*

Pruébalo en línea!

Explicación

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

Pyth - 5 bytes

jS{.p

Pruébelo en línea aquí .

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

Haskell, 46 bytes

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

2 bytes guardados gracias a nimi

J, 19 bytes

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

Caso de prueba

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

Explicación

Este es un tren de 4:

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

Básicamente:

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

JavaScript (Firefox 30+), 129124 bytes

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]

No está mal para un idioma sin permutación incorporada ...

Python 3.5, 81 bytes:

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

Realmente ... 81 bytes cuando la siguiente respuesta más larga es 48 bytes ... suspiro . Bueno, intentaré este golf tanto como pueda, pero los consejos de golf todavía son muy apreciados.

Además, aquí está la solución más corta que pude obtener en Python 2 en 86 bytes :

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

Aparentemente en Python 2, [*...]devuelve a Syntax Error, y como permutationsdevuelveitertools.permutations object at 0x... , la siguiente forma más corta (que sé) de extraer las permutaciones únicas es usar {''.join(i)for i in permutations(f)}where fes la cadena de entrada.

Finalmente, tenga en cuenta que estas son funciones lambda y, por lo tanto, deben llamarse en el formato print(<Function Name>(<Input String>)).

Mathematica, 34 23 bytes

Print@@@Permutations@#&

La entrada debe ser una lista de caracteres.

Explicación

Permutations@

Encuentre todas las permutaciones de la entrada, ordenadas y sin duplicados.

Print@@@

Imprimirlos uno por uno.

Brachylog , 9 bytes

:pfdo~@nw

Pruébalo en línea!

Explicación

: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 bytes

Cadena como entrada

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

Lista de caracteres como entrada

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

Expandido

*\              # 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 bytes

pᵘoẉᵐ

Pruébalo en línea!

Encuentra ᵘnique permutations de entrada, s oellos, RT ᵐAP ẉriteln (escritura con la nueva línea) sobre la matriz.

Python 3, 77 85 bytes

Ahora tipo!

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

PowerShell v3 +, 171 bytes

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 introdujo el -Uniqueindicador en el Sort-Objectcmdlet, por lo que es unos pocos bytes más corto que la versión v2 a continuación, ya que no necesitamos Selectprimero.

Versión v2, 178 bytes:

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 no tiene permutaciones integradas, por lo que tomé prestado mi código de Prime Factors Buddies y lo modifiqué ligeramente para usarlo aquí.

Esto es esencialmente tres porciones, que ampliaré a continuación.

param([char[]]$x)$a,$b=$x;$a=,$aToma la entrada $x, la charconvierte como una matriz, elimina la primera letra $ay el resto $b, y luego la vuelve a proyectar $acomo una matriz con el operador de coma.

while($b){$z,$b=$b;$a+=$a|%{0..($y=($c="$_").Length)|%{-join($c[0..$_]+$z+$c[++$_..$y])};"$z$c";"$c$z"}}Recorre las letras restantes ( $b), cada iteración toma la siguiente letra y la almacena $zy la deja dentro $b, luego concatena la matriz en $ael resultado del envío$a través de su propio bucle: cada elemento de $a(almacenado temporalmente $c) se repite propio .length, y luego $zse inserta en cada posición, incluso anteponer y anexar con $z$cy $c$z. Por ejemplo, para $c = '12'y $z = '3', esto dará como resultado que '132','312','123'se concatenen nuevamente $a.

La parte final $a|?{$_.length-eq$x.count}|select -u|sorttoma cada elemento de $ay usa la Where-Objectcláusula para filtrar solo aquellos que tienen la misma longitud que la cadena de entrada, luegoselect solo los -uelementos nique y finalmente sortlos alfabéticamente. Todas las cadenas resultantes se dejan en la tubería, y la salida a través de lo implícito Write-Outputocurre al finalizar el programa.

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 bytes

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`

Donde \nrepresenta el carácter literal de nueva línea. La respuesta del puerto de @ ETHproduction para usar cadenas en lugar de matrices. Invertir la salida, o mover la nueva línea al comienzo, ahorra 3 bytes.

R, 113 bytes

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

Lee la entrada de stdin. Se permutesupone que el paquete está instalado para llamar a la allPermsfunción.

Agregaré una explicación cuando llegue a casa del trabajo.

Java 302 300 bytes

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;}}

Ungolfed y código de prueba:

Pruébalo aquí

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);
    }
  }
}

Entrada: prueba
Salida:

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

Raqueta 82 bytes

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

Sin golf:

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

Pruebas:

(f "buzz")

Ouput:

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

Groovy, 69 bytes

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

Ruby, 51 bytes

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

Actualmente , 8 bytes

Sugerencias de golf bienvenidas! Pruébalo en línea!

;l@╨♂Σ╔i

No golfista

     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 bytes

7 bytes de código, +1 para -nbandera.

SSUQPMa

Toma una cadena como argumento de línea de comandos. Pruébalo en línea!

El escáner de Pip divide series de letras mayúsculas en pedazos de dos letras. Entonces, este código es SS UQ PM a--ie SortString(UniQue(PerMutations(a))), asiendo la línea de comando arg. El -nindicador garantiza que la lista de resultados esté separada por una nueva línea. Eso es todo al respecto.

K (oK) , 14 bytes

Solución:

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

Pruébalo en línea!

Explicación:

Use la función de permutación incorporada, prm para generar permutaciones de longitud de la entrada, aplique estas permutaciones a la entrada, ordene alfabéticamente y luego tome valores distintos.

?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 bytes

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

Pruébalo en línea!

Japt v2.0a0 -R, 5 bytes

á â n

Intentalo

C ++ (gcc) , 132128 bytes

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

Pruébalo en línea!

Almeja , 9 bytes

p_D`Sq@~Q

Explicación

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