Aufgabe

Ihr Ziel ist es, ein Programm zu schreiben, das bei gegebener Eingabezeichenfolge (oder einem Array von Zeichen) jede mögliche Permutation der Buchstaben in dieser Zeichenfolge ausgibt. Ich bin pingelig mit meiner Ausgabe, daher sollte sie alphabetisch sortiert sein, ohne Duplikate.

Beispiel:

Eingang: buzz

Ausgabe:

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

Regeln

• Das ist Code-Golf, also gewinnt der kürzeste Code.
• Nachgestellte Leerzeichen in jeder Zeile sind in Ordnung
• Eine einzelne Zeile nach der letzten Zeile ist zulässig (aber nicht mehr).

Gelee , 5 Bytes

ṢŒ!QY

Probieren Sie es online!

Erläuterung

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

05AB1E ,  4  3 Bytes

Aktualisiert, da ein Update auf œdie alte Version,
die auch ein Byte wie von Magic Octopus Urn vorgeschlagen gespeichert brach .

œê»

Probieren Sie es online!

Erläuterung

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

MATL , 4 Bytes

Y@Xu

Probieren Sie es online!

Erläuterung

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)

Eine Funktion, die Eingaben als Liste von Zeichen und Ausgaben beim Drucken annimmt.

Erstellt rekursiv jede eindeutige Permutation, indem jedes mögliche nächste Zeichen alphabetisch aus den verbleibenden eindeutigen Zeichen herausgenommen und an die laufende Ausgabe angehängt wird w. Dann wiederholen wir den Vorgang, wobei dieses Zeichen entfernt wurde. Sobald die Eingabe geleert ist, drucken wir w.

CJam , 5 Bytes

Danke an @EriktheOutgolfer für eine Korrektur ( qstatt r)

qe!N*

Probieren Sie es online!

Erläuterung

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

Pyth - 5 Bytes

jS{.p

Probieren Sie es hier online aus .

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 gespart dank nimi

J, 19 Bytes

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

Testfall

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

Erläuterung

Dies ist ein 4-Zug:

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

Grundsätzlich gilt:

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

Nicht schlecht für eine Sprache ohne eingebaute Permutation ...

Python 3.5, 81 Bytes:

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

Wirklich ... 81 Bytes, wenn die nächstlängste Antwort 48 Bytes ist ... seufz . Nun, ich werde dieses Golfspiel so oft wie möglich ausprobieren, aber Golftipps werden immer noch sehr geschätzt.

Auch hier ist die kürzeste Lösung, die ich in Python 2 mit 86 Bytes bekommen konnte :

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

Offenbar in Python 2, [*...]kehrt ein Syntax Error, und da permutationskehrt itertools.permutations object at 0x...der nächste kürzeste Weg (die ich kenne) die Extraktions einzigartigen Permutationen verwendet , {''.join(i)for i in permutations(f)}wo fist die Eingabezeichenfolge.

Beachten Sie abschließend, dass dies beide Lambda-Funktionen sind und daher im Format aufgerufen werden müssen print(<Function Name>(<Input String>)).

Mathematica, 34 23 Bytes

Print@@@Permutations@#&

Die Eingabe muss eine Liste von Zeichen sein.

Erläuterung

Permutations@

Hier finden Sie alle Permutationen der Eingabe, sortiert und duplikationsfrei.

Print@@@

Drucken Sie sie einzeln aus.

Brachylog , 9 Bytes

:pfdo~@nw

Probieren Sie es online!

Erläuterung

: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 als Eingabe

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

Liste der Zeichen als Eingabe

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

Erweitert

*\              # 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ẉᵐ

Probieren Sie es online!

Finden ᵘnique permutations der Eingabe, s ort sie, ᵐap ẉriteln (Schreiben mit Newline) über das Array.

Python 3, 77-85 Bytes

Jetzt sortiert!

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

In PowerShell v3 wurde das -UniqueFlag für das Sort-ObjectCmdlet eingeführt, sodass es einige Bytes kürzer ist als die Version unter v2, da dies nicht erforderlich ist Select.

v2 version, 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

In PowerShell sind keine Permutationen integriert, daher habe ich meinen Code von Prime Factors Buddies ausgeliehen und ihn für die Verwendung hier leicht optimiert.

Dies sind im Wesentlichen drei Teile, auf die ich im Folgenden näher eingehen werde.

param([char[]]$x)$a,$b=$x;$a=,$aNimmt Eingaben auf $x, charwandelt sie als -array um, entfernt den ersten Buchstaben $aund den Rest $bund setzt sie dann $amit dem Komma-Operator als Array um.

while($b){$z,$b=$b;$a+=$a|%{0..($y=($c="$_").Length)|%{-join($c[0..$_]+$z+$c[++$_..$y])};"$z$c";"$c$z"}}Durchläuft die verbleibenden Buchstaben ( $b), wobei jede Iteration den nächsten Buchstaben aufnimmt $zund in die verbleibenden Buchstaben speichert und diese $bdann in einem Array auf $adas Ergebnis des Sendens $ain einer eigenen Schleife verkettet - jedes Element von $a(temporär gespeichert in $c) wird durchlaufen seine eigene .length, und dann $zwird in jeder Position eingefügt, einschließlich Voranstellen und Anhängen mit $z$cund $c$z. Zum Beispiel für $c = '12'und $z = '3'wird dies dazu führen , '132','312','123'in wird verketteten zurück $a.

Der letzte Teil $a|?{$_.length-eq$x.count}|select -u|sortnimmt jedes Element von $aund verwendet eine Where-ObjectKlausel, um nur diejenigen herauszufiltern, die die gleiche Länge wie die Eingabezeichenfolge haben, dann selectnur die -uNique-Elemente und schließlich sortdiese alphabetisch. Die resultierenden Zeichenfolgen verbleiben alle in der Pipeline und werden implizit Write-Outputnach Programmabschluss ausgegeben .

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`

Wobei \ndas wörtliche Zeilenumbruchzeichen darstellt. Die Antwort von Port of @ ETHproduction, Strings anstelle von Arrays zu verwenden. Das Umkehren der Ausgabe oder das Verschieben der nachgestellten Zeile an den Anfang spart 3 Bytes.

R, 113 Bytes

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

Liest die Eingabe von stdin. Es permutewird davon ausgegangen, dass das Paket installiert ist, um die allPermsFunktion aufzurufen .

Füge eine Erklärung hinzu, wenn ich von der Arbeit nach Hause komme.

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 & Testcode:

Probieren Sie es hier aus.

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

Eingang: Test
Ausgang:

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

Schläger 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<?))

Testen:

(f "buzz")

Ausgang:

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

Eigentlich 8 Bytes

Golfvorschläge willkommen! Probieren Sie es 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 Byte Code, +1 für -nFlag.

SSUQPMa

Nimmt eine Zeichenfolge als Befehlszeilenargument. Probieren Sie es online!

Pips Scanner zerlegt Serien von Großbuchstaben in Zwei-Buchstaben-Blöcke. Dieser Code ist also SS UQ PM a--ie SortString(UniQue(PerMutations(a))), wobei aes sich um das Befehlszeilenargument handelt. Das -nFlag stellt sicher, dass die Ergebnisliste durch Zeilenumbrüche getrennt ist. Das ist alles dazu.

K (oK) , 14 Bytes

Lösung:

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

Probieren Sie es online!

Erläuterung:

Verwenden Sie die integrierte Permutationsfunktion, prmum Permutationen der Länge der Eingabe zu generieren, wenden Sie diese Permutationen auf die Eingabe an, sortieren Sie sie alphabetisch und nehmen Sie dann unterschiedliche Werte an.

?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

Probieren Sie es online!

Japt v2.0a0 -R, 5 Bytes

á â n

Versuch es

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

Probieren Sie es online!

Muschel , 9 Bytes

p_D`Sq@~Q

Erläuterung

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