Diese Frage basiert stark auf dieser Frage , sollte jedoch eine Reihe zusätzlicher Schwierigkeiten aufwerfen .

Deine Aufgabe

Sie müssen ein Programm oder eine Funktion schreiben, die beim Empfang eines Strings alle möglichen Anagramme davon ausgibt. Im Sinne dieser Frage ist ein Anagramm eine Zeichenfolge, die dasselbe Zeichen wie die ursprüngliche Zeichenfolge enthält, jedoch nicht die ursprüngliche Zeichenfolge. Ein Subanagramm ist ein Anagramm eines Teilstrings eines eingegebenen Strings. Anagramme und Subanagramme müssen keine tatsächlichen Wörter sein oder enthalten.

Eingang

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

Ausgabe

Sie können alle möglichen Anagramme und Unterdiagramme 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 , 7 Bytes

Œ€œ˜Ù¹K

Eine Funktion, die eine Zeichenfolge von der Eingabe akzeptiert und eine Liste von Zeichenfolgen auf dem Stapel hinterlässt. Als vollständiges Programm wird eine Darstellung der Liste gedruckt.

Probieren Sie es online!

Wie?

        - push input
Π      - all substrings
 €œ     - for €ach: all permutations
   ˜    - flatten
    Ù   - de-duplicate
     ¹  - push 1st input onto top of stack
      K - pop a,b; push a without any b's (remove the copy of the input from the list)
        - as a full program: implicit print of the top of the stack

Brachylog (2), 7 Bytes

{sp}ᶠdb

Probieren Sie es online!

Erläuterung

{sp}ᶠdb
{  }ᶠ    Find all
  p        permutations of
 s         a substring of {the input}
     d   Remove duplicates (leaving the list otherwise in the same order)
      b  Remove the first (the input itself)

Gelee , 9 Bytes

ẆŒ!€;/QḟW

Ein monadischer Link, der eine Liste akzeptiert und eine Liste aller unterschiedlichen Unteranagramme mit Ausnahme der Eingabe selbst zurückgibt.

Probieren Sie es online!(Die Fußzeile druckt die resultierende Liste schön aus, indem sie mit Zeilenumbrüchen verbunden wird.)

Wie?

ẆŒ!€;/QḟW - Link: list of characters, s
Ẇ         - all contiguous sublists of s
 Œ!€      - all permutations for €ach sublist now a list of lists of lists)
     /    - reduce by:
    ;     -   concatenation (flattens the list by one level)
      Q   - de-duplicate (gets the unique entries)
        W - wrap s in a list (otherwise filtering will attempt to remove characters)
       ḟ  - filter discard from left if in right (remove the one equal to the input)

Pyth, 12

-{.n.pM.:Q)]

Online-Test .

         Q       # input
       .: )      # all substrings
    .pM          # all permutations of all substrings
  .n             # flatten
 {               # deduplicate
-          ]Q    # subtract (list of) (implicit) input

Japt , 10 Bytes

à má c â Å

Probieren Sie es online!

Ich àmuss á, und verwendenâ alle in einer Antwort auch in Ordnung. Was für ein Zufall...

Erläuterung

 à má c â Å
Uà má c â s1  // Ungolfed
              // Implicit: U = input string
Uà            // Take all combinations of characters in the input string.
   má         // Map each combination to all of its permutations.
      c       // Flatten into a single array.
        â     // Uniquify; remove all duplicates.
          s1  // Remove the first item (the input) from the resulting array.
              // Implicit: output resulting array, separated by commas

Mathematica, 60 Bytes

DeleteCases[""<>#&/@Permutations[c=Characters@#,Tr[1^c]],#]&

PermutationsVerwendet ein optionales numerisches Argument, das angibt, wie viele der Eingabewerte für die Permutationen verwendet werden sollen. Wenn wir die Länge der Eingabe angeben, werden die Permutationen für alle Teilmengen der Eingabe ohne Duplikate generiert. Alles was wir tun müssen, ist die Eingabe zu entfernen.

Java 8, 313 312 306 Bytes

import java.util.*;s->{Set l=new HashSet();for(int z=s.length(),i=0,j;i<z;i++)for(j=i;j<z;p("",s.substring(i,j+++1),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+++1,n),l));}

Geänderte Version meiner Antwort hier , wo p("",s,l);durch ersetzt wurdefor(int z=s.length(),i=0,j;i<z;i++)for(j=i;j<z;p("",s.substring(i,j+++1),l));

-6 Bytes dank @ OlivierGrégoire in meiner verknüpften Antwort.

Erklärung dieses Teils:

Probieren Sie es hier aus.

for(int l=s.length(),i=0,j;i<l;i++)
                               // Loop (1) from 0 to the length of the String (exclusive)
  for(j=i+1;j<=l;              //  Loop (2) from 1 to the length of the String (exclusive)
    p("",                      //   Call the permutation-method,
    s.substring(i,j+++1),l));  //   with a substring from `i` to `j` (inclusive)
                               //  End of loop (2) (implicit / single-line body)
                               // End of loop (1) (implicit / single-line body)

Perl 6 , 75 Bytes

{unique(flat $_,.comb.combinations.skip».permutations.map(*».join)).skip}

Versuch es

Erweitert:

{                    # bare block lambda with implicit parameter ｢$_｣

  unique(            # return each (sub)anagram once

    flat             # unstructure the following (List of Lists into flat List)
      $_,            # the input (so we can skip it at the end)

      .comb          # split the input into graphemes
      .combinations  # get all the combinations
      .skip\         # skip the first empty combination
      ».permutations # get all the permutations of each combination
      .map(*».join)  # join the inner permutations

  ).skip             # skip the first value (the input)
}