A pesar de tener 17 preguntas etiquetadas anagramas , todavía no tenemos esta pregunta, así que aquí está.

Tu tarea

Debe escribir un programa o función que, al recibir una cadena, imprima todos los anagramas posibles de la misma. A los fines de esta pregunta, un anagrama es una cadena que contiene el mismo carácter que la cadena original, pero no es una copia exacta de la cadena original. Un anagrama no tiene que ser o contener palabras reales.

Entrada

Puede aceptar la cadena, que puede ser de cualquier longitud> 0, por cualquier método de entrada estándar. Puede contener caracteres ASCII.

Salida

Puede generar todos los anagramas posibles de la cadena ingresada de cualquier manera estándar. No debe generar la misma cadena dos veces, ni generar una cadena igual a la entrada.

Otras reglas

Las lagunas estándar no están permitidas

Puntuación

Este es el código de golf , gana menos bytes.

05AB1E , 3 bytes

œÙ¦

Una función que deja la pila con una lista de los anagramas en la parte superior (y como su único elemento). Como un programa completo imprime una representación de esa lista.

Pruébalo en línea!

¿Cómo?

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

Pruébalo en línea!

A pesar de tener una función incorporada, la palabra "permutación" es realmente larga :(

MATL , 7 bytes

tY@1&X~

Pruébalo en línea!

Explicación

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

Prueba en línea .

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

Japt , 6 bytes

á â kU

Pruébalo en línea!

Explicación

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

Pruébalo en línea!

Guardado 8 bytes gracias a la tailsugerencia de Leo .

CJam , 8 bytes

l_e!\a-p

Pruébalo en línea!

Explicación

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

Jalea , 4 bytes

Œ!QḊ

Un enlace monádico que toma una lista de caracteres y devuelve una lista de listas de caracteres, todos anagramas distintos que no son iguales a la entrada.

Pruébalo en línea! (el pie de página forma un programa que se une a la lista mediante nuevas líneas e impresiones para evitar la representación destrozada).

¿Cómo?

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

Como una función, y devolviendo cadenas como una lista de caracteres (gracias a @ pizzapants184 por decirme que está permitido):

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

Como una función:

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

85 bytes como un programa completo:

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

Podría reducirse un poco si la salida de cadenas como ('a', 'b', 'c') está permitida (no estoy seguro de que lo sea).

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 gracias a @ OlivierGrégoire .

Java verbosa típica. Veo muchas respuestas de <10 bytes, y aquí estoy con más de 200 bytes. XD

Explicación:

Pruébalo aquí

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

Intentalo

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

Intentalo

Expandido

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

sin 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

Solución:

1_?x@prm@!#x:

Pruébalo en línea!

Explicación:

La evaluación se realiza de derecha a izquierda.

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

Adoptado de una respuesta anterior mía .

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

Pruébalo en línea!