Pur avendo 17 domande taggate anagrammi , non abbiamo ancora questa domanda, quindi eccola qui.

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 è una copia esatta della stringa originale. Un anagramma non deve essere o contenere parole reali.

Ingresso

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

Produzione

È possibile emettere tutti i possibili anagrammi 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 , 3 byte

œÙ¦

Una funzione che lascia la pila con un elenco di anagrammi in cima (e come unico oggetto). Come programma completo stampa una rappresentazione di tale elenco.

Provalo online!

Come?

    - 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

Rubino , 45 byte

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

Provalo online!

Nonostante abbia un built-in, la parola "permutazione" è davvero lunga :(

MATL , 7 byte

tY@1&X~

Provalo online!

Spiegazione

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 online .

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

Japt , 6 byte

á â kU

Provalo online!

Spiegazione

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

import Data.List
a=tail.nub.permutations

Provalo online!

Risparmiato 8 byte grazie al tailsuggerimento di Leo .

CJam , 8 byte

l_e!\a-p

Provalo online!

Spiegazione

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 byte

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

Gelatina , 4 byte

Œ!QḊ

Un collegamento monadico che prende un elenco di caratteri e restituisce un elenco di elenchi di caratteri - tutti anagrammi distinti che non sono uguali all'input.

Provalo online! (il piè di pagina forma un programma che unisce l'elenco con nuove righe e stampe per evitare la rappresentazione altrimenti fracassata).

Come?

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

Come funzione, e restituendo le stringhe come elenco di caratteri (grazie a @ pizzapants184 per avermi detto che è permesso):

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

Come una funzione:

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

85 byte come programma completo:

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

Potrebbe ridursi un po 'se è consentito emettere stringhe come (' a ',' b ',' c ') (non sono sicuro che lo sia).

Java 8, 245 239 237 byte

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

Java verbosa tipica .. Vedo molte risposte <10 byte, ed eccomi qui con oltre 200 byte .. XD

Spiegazione:

Provalo qui.

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 byte

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

Provalo

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

Provalo

allargato

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

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