Bien que nous ayons 17 questions avec des anagrammes , nous n'avons toujours pas cette question, alors la voici.

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 une copie exacte de la chaîne d'origine. Une anagramme ne doit pas nécessairement être ou contenir des mots réels.

Contribution

Vous pouvez accepter la 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 afficher toutes les anagrammes possibles de la chaîne saisie 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

Les échappatoires standard ne sont pas autorisées

Notation

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

05AB1E , 3 octets

œÙ¦

Une fonction qui laisse la pile avec une liste des anagrammes en haut (et comme son seul élément). Un programme complet imprime une représentation de cette liste.

Essayez-le en ligne!

Comment?

    - 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

Rubis , 45 octets

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

Essayez-le en ligne!

En dépit d'avoir un intégré, le mot "permutation" est vraiment long :(

MATL , 7 octets

tY@1&X~

Essayez-le en ligne!

Explication

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

Test en ligne .

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

Japt , 6 octets

á â kU

Essayez-le en ligne!

Explication

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

import Data.List
a=tail.nub.permutations

Essayez-le en ligne!

Enregistré 8 octets grâce à l' tailastuce de Leo .

CJam , 8 octets

l_e!\a-p

Essayez-le en ligne!

Explication

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 octets

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

Gelée , 4 octets

Œ!QḊ

Un lien monadique prenant une liste de caractères et renvoyant une liste de listes de caractères - toutes des anagrammes distinctes qui ne sont pas égales à l'entrée.

Essayez-le en ligne! (le pied de page forme un programme qui rejoint la liste par des retours à la ligne et des impressions pour éviter la représentation autrement brisée).

Comment?

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

En tant que fonction, et renvoyer des chaînes sous forme de liste de caractères (merci à @ pizzapants184 de m'avoir dit que c'est autorisé):

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

En tant que fonction:

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

85 octets en tant que programme complet:

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

Pourrait être réduit un peu si la sortie de chaînes comme ('a', 'b', 'c') est autorisée (je ne suis pas sûr que ce soit le cas).

Java 8, 245 239 237 octets

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 octets grâce à @ OlivierGrégoire .

Java verbeux typique .. Je vois beaucoup de réponses <10 octets, et me voici avec plus de 200 octets .. XD

Explication:

Essayez-le ici.

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 octets

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

Essayez-le

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

Essayez-le

Étendu

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

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

non golfé

#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

Solution:

1_?x@prm@!#x:

Try it online!

Explanation:

Evaluation is performed right-to-left.

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 bytes

Adopted from a past answer of mine.

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

Try it online!