Compito

Il tuo obiettivo, se scegli di accettarlo, è scrivere un programma che, data una stringa di input (o matrice di caratteri), generi ogni possibile permutazione delle lettere in quella stringa. Sono pignolo con il mio output, quindi dovrebbe essere ordinato in ordine alfabetico, senza duplicati.

Esempio:

Ingresso: buzz

Produzione:

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

Regole

• Questo è code-golf, quindi vince il codice più corto.
• Gli spazi finali su ciascuna / qualsiasi riga sono ok
• È consentita una sola nuova riga dopo l'ultima riga (ma non più)

Gelatina , 5 byte

ṢŒ!QY

Provalo online!

Spiegazione

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

05AB1E ,  4  3 byte

Aggiornato, dal momento che un aggiornamento ha œrotto la vecchia versione,
che ha anche salvato un byte come suggerito da Magic Octopus Urn .

œê»

Provalo online!

Spiegazione

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

MATL , 4 byte

Y@Xu

Provalo online!

Spiegazione

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

Python 3.5, 79 byte

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

Una funzione che accetta input come un elenco di caratteri e output mediante la stampa.

Esegue ricorsivamente ogni permutazione distinta estraendo alfabeticamente ogni possibile carattere successivo dai restanti caratteri distinti e aggiungendolo all'output in corso w. Quindi, riprendiamo con questo personaggio rimosso. Una volta svuotato l'input, stampiamo w.

CJam , 5 byte

Grazie a @EriktheOutgolfer per una correzione ( qanziché r)

qe!N*

Provalo online!

Spiegazione

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

Pyth - 5 byte

jS{.p

Provalo online qui .

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

Haskell, 46 byte

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

2 byte salvati grazie a nimi

J, 19 byte

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

Caso di prova

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

Spiegazione

Questo è un treno 4:

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

Fondamentalmente:

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

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]

Non male per una lingua senza permutazione integrata ...

Python 3.5, 81 byte:

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

Davvero ... 81 byte quando la risposta più lunga successiva è 48 byte ... sigh . Bene, proverò questo golf più che posso, ma i consigli sul golf sono ancora molto apprezzati.

Inoltre, ecco la soluzione più breve che potrei ottenere in Python 2 a 86 byte :

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

Apparentemente in Python 2, [*...]restituisce a Syntax Error, e poiché permutationsrestituisce itertools.permutations object at 0x..., il modo più breve successivo (che conosco) di estrarre le permutazioni uniche è usare {''.join(i)for i in permutations(f)}dove fè la stringa di input.

Infine, nota che queste sono entrambe funzioni lambda e quindi devono essere chiamate nel formato print(<Function Name>(<Input String>)).

Mathematica, 34 23 byte

Print@@@Permutations@#&

L'input deve essere un elenco di caratteri.

Spiegazione

Permutations@

Trova tutte le permutazioni dell'input, ordinate e duplicate gratuitamente.

Print@@@

Stampali uno per uno.

Brachylog , 9 byte

:pfdo~@nw

Provalo online!

Spiegazione

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

Stringa come input

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

Elenco di caratteri come input

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

allargato

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

pᵘoẉᵐ

Provalo online!

Trova ᵘnique permutations di ingresso, s oloro, rt ᵐap ẉriteln (scrittura con la nuova linea) su quella matrice.

Python 3, 77 85 byte

Adesso sorta!

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

PowerShell v3 +, 171 byte

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 ha introdotto il -Uniqueflag suSort-Object cmdlet, quindi è più corto di alcuni byte rispetto alla versione v2 di seguito, poiché non è necessarioSelect prima.

versione v2, 178 byte:

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 non ha permutazioni integrate, quindi ho preso in prestito il mio codice Prime Factors Buddies e l'ho leggermente modificato per l'uso qui.

Si tratta essenzialmente di tre parti, che espanderò di seguito.

param([char[]]$x)$a,$b=$x;$a=,$aPrende l'input $x, lo lancia come un chararray, rimuove la prima lettera in $ae il resto in $b, quindi si ripete $acome array con l'operatore virgola.

while($b){$z,$b=$b;$a+=$a|%{0..($y=($c="$_").Length)|%{-join($c[0..$_]+$z+$c[++$_..$y])};"$z$c";"$c$z"}}Passa attraverso le lettere rimanenti ( $b), ogni iterazione prende la lettera successiva e la memorizza in $ze lasciando la rimanente $b, quindi si concatena in $aserie sul risultato dell'invio $aattraverso il proprio ciclo - ogni elemento di $a(temporaneamente memorizzato in $c) viene ripetuto proprio .length, e quindi $zviene inserito in ogni posizione, incluso anteporre e aggiungere con $z$ce $c$z. Ad esempio, per $c = '12'e $z = '3', ciò comporterà di '132','312','123'essere nuovamente concatenato in $a.

La parte finale $a|?{$_.length-eq$x.count}|select -u|sortprende ogni elemento $ae usa la Where-Objectclausola per filtrare solo quelli che hanno la stessa lunghezza della stringa di input, quindi selectsolo gli -uelementi di nicchia e infine sortquelli alfabetici. Le stringhe risultanti vengono lasciate tutte sulla pipeline e l'output tramite implicito Write-Outputavviene al completamento del programma.

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 byte

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`

Dove \n rappresenta il carattere letterale di newline. Port della risposta di @ ETHproduzione per usare stringhe invece di array. L'inversione dell'output o lo spostamento della nuova riga finale all'inizio salva 3 byte.

R, 113 byte

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

Legge input da stdin. Ilpermute presume che il pacchetto sia installato per chiamare la allPermsfunzione.

Aggiungerò una spiegazione mentre torno a casa dal lavoro.

Java 302 300 byte

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

Codice non testato e test:

Provalo qui.

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

Ingresso: test
Uscita:

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

Racchetta 82 byte

(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<?))

test:

(f "buzz")

ouput:

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

Groovy, 69 byte

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

Rubino, 51 byte

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

In realtà , 8 byte

Suggerimenti di golf benvenuti! Provalo 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.

seme , 8 byte

7 byte di codice, +1 per la -nbandiera.

SSUQPMa

Accetta una stringa come argomento della riga di comando. Provalo online!

Lo scanner di Pip spezza serie di lettere maiuscole in blocchi di due lettere. Quindi questo codice è SS UQ PM a--ie SortString(UniQue(PerMutations(a))), con al'arg della riga di comando. Il -nflag assicura che l'elenco dei risultati sia separato da una nuova riga. Questo è tutto quello che c'è da fare.

K (oK) , 14 byte

Soluzione:

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

Provalo online!

Spiegazione:

Utilizzare la funzione di permutazione integrata, prmper generare permutazioni della lunghezza dell'input, applicare queste permutazioni all'input, ordinare in ordine alfabetico e quindi assumere valori distinti.

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

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

Provalo online!

Japt v2.0a0 -R, 5 byte

á â n

Provalo

C ++ (gcc) , 132 128 byte

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

Provalo online!

Clam , 9 byte

p_D`Sq@~Q

Spiegazione

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