Obwohl wir 17 Fragen mit Anagrammen haben , haben wir diese Frage immer noch nicht, also hier ist sie.

Deine Aufgabe

Sie müssen ein Programm oder eine Funktion schreiben, die beim Empfang eines Strings alle möglichen Anagramme davon ausgibt. Für die Zwecke dieser Frage ist ein Anagramm eine Zeichenfolge, die dasselbe Zeichen wie die ursprüngliche Zeichenfolge enthält, jedoch keine exakte Kopie der ursprünglichen Zeichenfolge ist. Ein Anagramm muss keine tatsächlichen Wörter sein oder enthalten.

Eingang

Sie können die Zeichenfolge, die eine beliebige Länge> 0 haben kann, mit einer beliebigen Standardeingabemethode akzeptieren. Es kann beliebige ASCII-Zeichen enthalten.

Ausgabe

Sie können alle möglichen Anagramme des eingegebenen Strings auf jede Standardweise ausgeben. Sie dürfen dieselbe Zeichenfolge nicht zweimal ausgeben oder eine der Eingabe entsprechende Zeichenfolge ausgeben.

Andere Regeln

Standard-Regelungslücken sind nicht zulässig

Wertung

Das ist Code-Golf , die wenigsten Bytes gewinnen.

05AB1E , 3 Bytes

œÙ¦

Eine Funktion, die den Stapel mit einer Liste der Anagramme oben (und als einziges Element) verlässt. Als vollständiges Programm wird eine Darstellung dieser Liste gedruckt.

Probieren Sie es online!

Wie?

    - push input
œ   - pop and push a list of all permutations (input appears at the head)
 Ù  - pop and push a list of unique items (sorted by first appearance)
  ¦ - pop and push a dequeued list (removes the occurrence of the input)
    - As a full program: implicit print of the top of the stack

Ruby , 45 Bytes

->x{(x.chars.permutation.map(&:join)-[x])|[]}

Probieren Sie es online!

Trotz eingebautem Code ist das Wort "Permutation" sehr lang :(

MATL , 7 Bytes

tY@1&X~

Probieren Sie es online!

Erläuterung

t     % Implicitly input a string, say of length n. Duplicate
Y@    % All permutations. May contain duplicates. Gives a 2D char array of 
      % size n!×n with each permutation in a row
1&X~  % Set symmetric difference, row-wise. Automatically removes duplicates.
      % This takes the n!×n char array and the input string (1×n char array)
      % and produces an m×n char array containing the rows that are present 
      % in exactly one of the two arrays
      % Implicitly display

pyth , 8 4

-{.p

Online-Test .

  .pQ     # all permutations of the (implicit) input string
 {        # de-duplicate
-    Q    # subtract (implicit) input

Japt , 6 Bytes

á â kU

Probieren Sie es online!

Erläuterung

 á â kU
Uá â kU   // Ungolfed
          // Implicit: U = input string
Uá        // Take all permutations of U.
   â      // Remove duplicates.
     kU   // Remove U itself from the result.
          // Implicit: output resulting array, separated by commas

Haskell, 48 40 Bytes

import Data.List
a=tail.nub.permutations

Probieren Sie es online!

8 Bytes gespart dank Leos tailTipp.

CJam , 8 Bytes

l_e!\a-p

Probieren Sie es online!

Erläuterung

l    e# Read string from input
_    e# Duplicate
e!   e# Unique permutations. Gives a list of strings
\    e# Swap
a    e# Wrap in a singleton array
-    e# Set difference. This removes the input string
p    e# Pretty print the list

Mathematica, 47 Bytes

Drop[StringJoin/@Permutations[Characters@#],1]&

Gelee , 4 Bytes

Œ!QḊ

Ein monadischer Link, der eine Liste von Zeichen aufnimmt und eine Liste von Listen von Zeichen zurückgibt - alle unterschiedlichen Anagramme, die nicht mit der Eingabe übereinstimmen.

Probieren Sie es online! (Die Fußzeile bildet ein Programm, das die Liste durch Zeilenumbrüche verbindet und druckt, um die sonst zertrümmerte Darstellung zu vermeiden.)

Wie?

Œ!QḊ - Link: list of characters     e.g. "text"
Œ!   - all permutations of the list      ["text","tetx","txet","txte","ttex","ttxe","etxt","ettx","extt","extt","ettx","etxt","xtet","xtte","xett","xett","xtte","xtet","ttex","ttxe","tetx","text","txte","txet"]
  Q  - de-duplicate                      ["text","tetx","txet","txte","ttex","ttxe","etxt","ettx","extt","xtet","xtte","xett"]
   Ḋ - dequeue (the first one = input)          ["tetx","txet","txte","ttex","ttxe","etxt","ettx","extt","xtet","xtte","xett"]

Python 3, 85 76 63 Bytes

Als Funktion und Rückgabe von Strings als Liste von Zeichen (danke an @ pizzapants184 für den Hinweis, dass dies zulässig ist):

from itertools import*
lambda z:set(permutations(z))-{tuple(z)}

Als eine Funktion:

from itertools import*
lambda z:map("".join,set(permutations(z))-{tuple(z)})

85 Bytes als volles Programm:

from itertools import*
z=input()
print(*map("".join,set(permutations(z))-{tuple(z)}))

Könnte ein wenig reduziert werden, wenn die Ausgabe von Strings als ('a', 'b', 'c') erlaubt ist (ich bin mir nicht sicher, ob dies der Fall ist).

Java 8, 245 239 237 Bytes

import java.util.*;s->{Set l=new HashSet();p("",s,l);l.remove(s);l.forEach(System.out::println);}void p(String p,String s,Set l){int n=s.length(),i=0;if(n<1)l.add(p);else for(;i<n;p(p+s.charAt(i),s.substring(0,i)+s.substring(++i,n),l));}

-6 Bytes dank @ OlivierGrégoire .

Typisch ausführliches Java. Ich sehe viele <10-Byte-Antworten, und hier bin ich mit mehr als 200 Bytes. XD

Erläuterung:

Probieren Sie es hier aus.

import java.util.*;         // Required import for the Set and HashSet

s->{                        // Method (1) with String parameter and no return-type
  Set l=new HashSet();      //  Set to save all permutations in (without duplicates)
  p("",s);                  //  Determine all permutations, and save them in the Set
  l.remove(s);              //  Remove the input from the Set
  l.forEach(                //  Loop over the Set
    System.out::println);   //   And print all the items
}                           // End of method (1)

// This method will determine all permutations, and save them in the Set:
void p(String p,String s,Set l){
  int n=s.length(),         //  Length of the first input String
      i=0;                  //  And a temp index-integer
  if(n<1)                   //  If the length is 0:
    l.add(p);               //   Add the permutation input-String to the Set
  else                      //  Else:
    for(;i<n;               //   Loop over the first input-String
      p(                    //    And do a recursive-call with:
        p+s.charAt(i),      //     Permutation + char
        s.substring(0,i)+s.substring(++i,n),l)
                            //     Everything except this char
      );                    //   End of loop
}                           // End of method (2)

Perl 6 ,  39  38 Bytes

*.comb.permutations».join.unique[1..*]

Versuch es

*.comb.permutations».join.unique.skip

Versuch es

Erweitert

*               # WhateverCode lambda (this is the parameter)
.comb           # split into graphemes
.permutations\  # get all of the permutations
».join          # join each of them with a hyper method call
.unique         # make sure they are unique
.skip           # start after the first value (the input)

C ++, 142 Bytes

#include<algorithm>
void p(std::string s){auto b=s;sort(begin(s),end(s));do if(s!=b)puts(s.data());while(next_permutation(begin(s),end(s)));}

ungolfed

#include <algorithm>

void p(std::string s)
{
    auto b = s;                    // use auto to avoid std::string
    sort(begin(s), end(s));        // start at first permutation
    do
      if (s != b)                  // only print permutation different than given string
        puts(s.data());
    while (next_permutation(begin(s), end(s))); // move to next permutation
}

K (oK) , 13 Bytes

Lösung:

1_?x@prm@!#x:

Probieren Sie es online!

Erläuterung:

Die Auswertung erfolgt von rechts nach links.

1_?x@prm@!#x: / the solution
           x: / store input in variable x
          #   / count length of x, #"abc" => 3
         !    / range, !3 => 0 1 2
     prm@     / apply (@) function permutations (prm) to range
   x@         / apply (@) these pumuted indixes back to original input
  ?           / return distinct values
1_            / drop the first one (ie the original input)

JavaScript (ES6), 101 Byte

Aus einer früheren Antwort von mir übernommen .

S=>(R=new Set,p=(s,m='')=>s[0]?s.map((_,i)=>p(a=[...s],m+a.splice(i,1))):R.add(m),_=p([...S]),[...R])

f=
S=>(R=new Set,p=(s,m='')=>s[0]?s.map((_,i)=>p(a=[...s],m+a.splice(i,1))):R.add(m),_=p([...S]),[...R])


console.log(
  f('ABC'),
  f('ABCD'),
  f('ABCC'),
  f('AABBC')
)

Perl 5 , 89 + 2 ( -F) = 91 Bytes

$,=$_;$"=",";map{say if!$k{$_}++&&$,ne$_&&(join"",sort@F)eq join"",sort/./g}glob"{@F}"x@F

Probieren Sie es online!