Apesar de ter 17 perguntas marcadas com anagramas , ainda não temos essa pergunta, então aqui está.

Sua tarefa

Você deve escrever um programa ou função que, ao receber uma string, imprima todos os anagramas possíveis. Para os fins desta pergunta, um anagrama é uma sequência que contém o mesmo caractere que a sequência original, mas não é uma cópia exata da sequência original. Um anagrama não precisa ser ou conter palavras reais.

Entrada

Você pode aceitar a sequência, que pode ter qualquer comprimento> 0, por qualquer método de entrada padrão. Pode conter caracteres ASCII.

Resultado

Você pode emitir todos os anagramas possíveis da string inserida de qualquer maneira padrão. Você não deve produzir a mesma sequência duas vezes ou produzir uma sequência igual à entrada.

Outras regras

As brechas padrão não são permitidas

Pontuação

Isso é código-golfe , menos bytes ganhos.

05AB1E , 3 bytes

œÙ¦

Uma função que deixa a pilha com uma lista dos anagramas no topo (e como seu único item). Como um programa completo, imprime uma representação dessa lista.

Experimente online!

Quão?

    - 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])|[]}

Experimente online!

Apesar de ter um built-in, a palavra "permutação" é realmente longa :(

MATL , 7 bytes

tY@1&X~

Experimente online!

Explicação

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

Teste online .

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

Japonês , 6 bytes

á â kU

Experimente online!

Explicação

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

Experimente online!

Economizou 8 bytes graças à taildica de Leo .

CJam , 8 bytes

l_e!\a-p

Experimente online!

Explicação

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]&

Jelly, 4 bytes

Œ!QḊ

A monadic link taking a list of characters and returning a list of lists of characters - all distinct anagrams that are not equal to the input.

Try it online! (the footer forms a program that joins the list by newlines and prints to avoid the otherwise smashed representation).

How?

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

As a function, and returning strings as list of characters (thanks to @pizzapants184 for telling me it is allowed):

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

As a function:

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

85 bytes as a full program:

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

Could be reduced a bit if outputting strings as ('a', 'b', 'c') is allowed (I am not sure it is).

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 thanks to @OlivierGrégoire.

Typical verbose Java.. I see a lot of <10 byte answers, and here I am with 200+ bytes.. XD

Explanation:

Try it here.

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..*]

Try it

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

Try it

Expanded

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

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!