Questa domanda è fortemente basata su questa domanda , ma dovrebbe comportare una serie di ulteriori difficoltà.

Il tuo compito

Devi scrivere un programma o una funzione che, quando riceve una stringa, ne stampa tutti i possibili anagrammi. Ai fini di questa domanda, un anagramma è una stringa che contiene lo stesso carattere della stringa originale, ma non è la stringa originale. Un subanagramma è un anagramma di una sottostringa di una stringa immessa. Anagrammi e subanagrammi non devono essere o contenere parole reali.

Ingresso

È possibile accettare una stringa, che può essere di qualsiasi lunghezza> 0, con qualsiasi metodo di input standard. Può contenere qualsiasi carattere ASCII.

Produzione

Puoi generare tutti i possibili anagrammi e subanagrammi della stringa immessa in qualsiasi modo standard. Non è necessario emettere due volte la stessa stringa o generare una stringa uguale all'input.

Altre regole

Le scappatoie standard non sono ammesse

punteggio

Questo è code-golf , vince meno byte.

05AB1E , 7 byte

Œ€œ˜Ù¹K

Una funzione che accetta una stringa dall'input e lascia un elenco di stringhe nello stack. Come programma completo viene stampata una rappresentazione dell'elenco.

Provalo online!

Come?

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

{sp}ᶠdb

Provalo online!

Spiegazione

{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)

Gelatina , 9 byte

ẆŒ!€;/QḟW

Un collegamento monadico che accetta un elenco e restituisce un elenco di tutti i sotto-anagrammi distinti tranne l'input stesso.

Provalo online! (il piè di pagina stampa in modo grazioso l'elenco risultante unendosi alle nuove righe.)

Come?

ẆŒ!€;/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)]

Test online .

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

Japt , 10 byte

à má c â Å

Provalo online!

Devo usare à, áe âtutto in una risposta, anche per ordine. Che coincidenza...

Spiegazione

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

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

Permutationsaccetta un argomento numerico opzionale che indica quanti dei valori di input utilizzare per le permutazioni. Se gli diamo la lunghezza dell'input, genererà le permutazioni per tutti i sottoinsiemi dell'input senza duplicati. Tutto quello che dobbiamo fare è rimuovere l'input.

Java 8, 313 312 306 byte

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

Versione modificata della mia risposta qui , dove p("",s,l);è stata sostituita confor(int z=s.length(),i=0,j;i<z;i++)for(j=i;j<z;p("",s.substring(i,j+++1),l));

-6 byte grazie a @ OlivierGrégoire nella mia risposta collegata.

Spiegazione di questa parte:

Provalo qui.

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 byte

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

Provalo

Allargato:

{                    # 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)
}