尽管有17个问题被标记 anagram的，我们仍然没有这个问题，所以就在这里。

你的任务

您必须编写一个程序或函数，该程序或函数在接收到字符串时会打印出所有可能的字谜。出于这个问题的目的，一个字谜是一个字符串，它包含与原始字符串相同的字符，但不是原始字符串的精确副本。字谜不必是或包含实际单词。

输入值

您可以通过任何标准输入法接受长度大于0的任何字符串。它可以包含任何ASCII字符。

输出量

您可以以任何标准方式输出输入字符串的所有可能的字谜。您不得输出相同的字符串两次，也不能输出与输入相等的字符串。

其他规定

不允许使用标准漏洞

计分

这是代码高尔夫球，最少字节获胜。

05AB1E，3 个字节

œÙ¦

该函数将堆栈中的字谜列表留在堆栈顶部（并且作为其唯一项）。完整的程序将显示该列表的表示形式。

在线尝试！

怎么样？

    - 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

红宝石，45个字节

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

在线尝试！

尽管具有内置功能，但“排列”一词的确很长：(

MATL，7个字节

tY@1&X~

在线尝试！

说明

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

在线测试。

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

Japt，6个字节

á â kU

在线尝试！

说明

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

import Data.List
a=tail.nub.permutations

在线尝试！

由于Leo的tail提示，节省了8个字节。

CJam，8个字节

l_e!\a-p

在线尝试！

说明

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个字节

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

果冻，4 字节

Œ!QḊ

单字链接，其中包含一个字符列表，并返回一个字符列表-所有与输入不相等的不同字谜。

在线尝试！（页脚形成一个程序，该程序通过换行符将列表连接起来并进行打印，以避免表示不正确的表示形式）。

怎么样？

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

作为一个函数，并返回字符串作为字符列表（感谢@ pizzapants184告诉我它被允许）：

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

作为功​​能：

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

完整程序为85个字节：

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

如果允许将字符串输出为（'a'，'b'，'c'），则可以减少一点（我不确定是这样）。

Java的8，245 239 237字节

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个字节 @OlivierGrégoire。

典型的冗长的Java ..我看到很多<10个字节的答案，而这里我有200个以上的字节.. XD

说明：

在这里尝试。

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个字节

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

尝试一下

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

尝试一下

展开式

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

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

不打高尔夫球

#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个字节

解：

1_?x@prm@!#x:

在线尝试！

说明：

评估从右到左执行。

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个字节

摘自我的过去答案。

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字节

$,=$_;$"=",";map{say if!$k{$_}++&&$,ne$_&&(join"",sort@F)eq join"",sort/./g}glob"{@F}"x@F

在线尝试！