Tarefa

Seu objetivo, se você optar por aceitá-lo, é escrever um programa que, dada uma string de entrada (ou matriz de caracteres), produza todas as permutações possíveis das letras nessa string. Eu sou meticuloso com minha saída, portanto deve ser classificado em ordem alfabética, sem duplicatas.

Exemplo:

Entrada: buzz

Saída:

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

Regras

• Isso é código-golfe, então o código mais curto vence.
• Os espaços à direita em cada / qualquer linha estão ok
• Uma única nova linha após a última linha é permitida (mas não mais)

Gelatina , 5 bytes

ṢŒ!QY

Experimente online!

Explicação

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

05AB1E ,  4  3 bytes

Atualizado, desde que uma atualização œquebrou a versão antiga,
que também salvou um byte, conforme sugerido pelo Magic Octopus Urn .

œê»

Experimente online!

Explicação

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

MATL , 4 bytes

Y@Xu

Experimente online!

Explicação

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)

Uma função que recebe entrada como uma lista de caracteres e saídas por impressão.

Recursivamente faz todas as permutações distintas, retirando cada caractere possível em ordem alfabética dos caracteres distintos restantes e anexando-o à saída em andamento w. Em seguida, recursamos com esse caractere removido. Quando a entrada é esvaziada, imprimimos w.

CJam , 5 bytes

Obrigado a @EriktheOutgolfer por uma correção (em qvez de r)

qe!N*

Experimente online!

Explicação

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

Pitão - 5 bytes

jS{.p

Experimente online aqui .

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 salvos graças a nimi

J, 19 bytes

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

Caso de teste

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

Explicação

Este é um trem de 4:

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

Basicamente:

/:~@~.@:{~!@#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 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]

Nada mal para uma linguagem sem permutação incorporada ...

Python 3.5, 81 bytes:

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

Realmente ... 81 bytes quando a próxima resposta mais longa for 48 bytes ... suspiro . Bem, vou tentar esse golfe o máximo que puder, mas as dicas de golfe ainda são muito apreciadas.

Além disso, aqui está a solução mais curta que eu poderia encontrar no Python 2 com 86 bytes :

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

Aparentemente, em Python 2, [*...]retorna ae Syntax Error, desde que permutationsretorna itertools.permutations object at 0x..., a próxima maneira mais curta (que eu conheço) de extrair as permutações exclusivas é usar {''.join(i)for i in permutations(f)}where fé a string de entrada.

Por fim, observe que essas são duas funções lambda e, portanto, devem ser chamadas no formato print(<Function Name>(<Input String>)).

Mathematica, 34 23 bytes

Print@@@Permutations@#&

A entrada deve ser uma lista de caracteres.

Explicação

Permutations@

Encontre todas as permutações da entrada, classificadas e sem duplicatas.

Print@@@

Imprima-os um por um.

Braquilog , 9 bytes

:pfdo~@nw

Experimente online!

Explicação

: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

String 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

Braquilog (v2), 5 bytes

pᵘoẉᵐ

Experimente online!

Encontrar ᵘ nique permutations de entrada, s ota-los, ᵐap ẉriteln (escrita com nova linha) sobre essa matriz.

Python 3, 77 85 bytes

Agora classifica!

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

O PowerShell v3 apresentou o -Unique sinalizador no Sort-Objectcmdlet, por isso é alguns bytes menor que a versão v2 abaixo, pois não precisamos Selectprimeiro.

versão 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

O PowerShell não possui permutações internas; portanto, emprestei meu código de Prime Factors Buddies e o ajustei levemente para uso aqui.

São essencialmente três porções, as quais expandirei abaixo.

param([char[]]$x)$a,$b=$x;$a=,$aRecebe entrada $x, lança como charmatriz, retira a primeira letra $ae o restante para $be depois reformula$a como uma matriz com o operador de vírgula.

while($b){$z,$b=$b;$a+=$a|%{0..($y=($c="$_").Length)|%{-join($c[0..$_]+$z+$c[++$_..$y])};"$z$c";"$c$z"}}Faz um loop pelas letras restantes ( $b), cada iteração pega a próxima letra e armazena $ze deixa a restante $b, concatenando a matriz no $aresultado do envio $aatravés de seu próprio loop - cada item de $a(armazenado temporariamente $c) é repetido próprio .lengthe, em seguida, $zé inserido em todas as posições, incluindo anexos e anexos com $z$ce $c$z. Por exemplo, para $c = '12'e $z = '3', isso resultará na '132','312','123'concatenação de volta ao$a .

A parte final $a|?{$_.length-eq$x.count}|select -u|sortpega cada elemento de $ae usa a Where-Objectcláusula para filtrar apenas aqueles que têm o mesmo comprimento que a sequência de entrada, depois selectapenas os -uitens específicos e finalmente sortos alfabéticos. As seqüências resultantes são todas deixadas no pipeline e a saída via implícita Write-Outputacontece na conclusão do 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`

Onde \nrepresenta o caractere literal de nova linha. Porta da resposta do @ ETHproduction para usar strings em vez de matrizes. Inverter a saída ou mover a nova linha à direita para o início economiza 3 bytes.

R, 113 bytes

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

Lê a entrada de stdin. opermute pacote é assumida para ser instalado, a fim de chamar a allPermsfunção.

Vou adicionar uma explicação quando eu chegar em casa do trabalho.

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 & código de teste:

Experimente aqui.

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: teste
Saída:

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

Raquete 82 bytes

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

Ungolfed:

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

Teste:

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

Na realidade , 8 bytes

Sugestões de golfe são bem-vindas! Experimente online!

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

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

SSUQPMa

Leva uma string como argumento da linha de comando. Experimente online!

O scanner de Pip divide as letras maiúsculas em pedaços de duas letras. Portanto, esse código é SS UQ PM a--ie SortString(UniQue(PerMutations(a))), asendo o argumento da linha de comando. O -nsinalizador garante que a lista de resultados seja separada por nova linha. É tudo o que há para isso.

K (oK) , 14 bytes

Solução:

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

Experimente online!

Explicação:

Use a função de permutação integrada,, prmpara gerar permutações de comprimento da entrada, aplique essas permutações à entrada, classifique em ordem alfabética e, em seguida, obtenha 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

Experimente online!

Japt v2.0a0 -R, 5 bytes

á â n

Tente

C ++ (gcc) , 132 128 bytes

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

Experimente online!

Amêijoa , 9 bytes

p_D`Sq@~Q

Explicação

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