Cette question est fortement basée sur cette question , mais devrait poser un certain nombre de difficultés supplémentaires.

Ta tâche

Vous devez écrire un programme ou une fonction qui, lors de la réception d'une chaîne, en imprime toutes les anagrammes possibles. Aux fins de cette question, une anagramme est une chaîne qui contient le même caractère que la chaîne d'origine, mais qui n'est pas la chaîne d'origine. Un sous-diagramme est une anagramme d'une sous-chaîne d'une chaîne entrée. Les anagrammes et sous-diagrammes ne doivent pas nécessairement être ou contenir des mots réels.

Contribution

Vous pouvez accepter une chaîne, qui peut être de n'importe quelle longueur> 0, par n'importe quelle méthode d'entrée standard. Il peut contenir n'importe quel caractère ASCII.

Production

Vous pouvez sortir toutes les anagrammes et sous-diagrammes possibles de la chaîne entrée de n'importe quelle manière standard. Vous ne devez pas sortir deux fois la même chaîne ou produire une chaîne égale à l'entrée.

Autres règles

Failles standard ne sont pas autorisées

Notation

C'est le code-golf , le moins d'octets gagne.

05AB1E , 7 octets

Œ€œ˜Ù¹K

Une fonction qui accepte une chaîne d'entrée et laisse une liste de chaînes sur la pile. En tant que programme complet, une représentation de la liste est imprimée.

Essayez-le en ligne!

Comment?

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

{sp}ᶠdb

Essayez-le en ligne!

Explication

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

Gelée , 9 octets

ẆŒ!€;/QḟW

Un lien monadique acceptant une liste et renvoyant une liste de toutes les sous-anagrammes distinctes à l'exception de l'entrée elle-même.

Essayez-le en ligne!(le pied de page imprime la liste résultante en se joignant aux nouvelles lignes.)

Comment?

ẆŒ!€;/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 en ligne .

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

Japt , 10 octets

à má c â Å

Essayez-le en ligne!

Je suis arrivé à utiliser à, áetâ tout en une seule réponse, dans l'ordre aussi. Quelle coïncidence...

Explication

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

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

Permutationsprend un argument numérique facultatif qui lui indique le nombre de valeurs d'entrée à utiliser pour les permutations. Si nous lui donnons la longueur de l'entrée, il générera les permutations pour tous les sous-ensembles de l'entrée sans doublons. Tout ce que nous devons faire est de supprimer l'entrée.

Java 8, 313 312 306 octets

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

Version modifiée de ma réponse ici , où p("",s,l);a été remplacé parfor(int z=s.length(),i=0,j;i<z;i++)for(j=i;j<z;p("",s.substring(i,j+++1),l));

-6 octets merci à @ OlivierGrégoire dans ma réponse liée.

Explication de cette partie:

Essayez-le ici.

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 octets

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

Essayez-le

Étendu:

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