任务

您的目标（应该选择接受）是编写一个程序，给定输入字符串（或字符数组），输出该字符串中字母的所有可能排列。我对自己的输出不满意，因此应按字母顺序排序，没有重复。

例：

输入： buzz

输出：

buzz
bzuz
bzzu
ubzz
uzbz
uzzb
zbuz
zbzu
zubz
zuzb
zzbu
zzub

规则

• 这是代码高尔夫球，因此最短的代码获胜。
• 每行上的尾随空格都可以
• 最后一行之后可以有一个换行符（但不能再有其他换行符）

果冻，5个字节

ṢŒ!QY

在线尝试！

说明

Ṣ         Sort
 Œ!       All permutations
   Q      Unique
    Y     Join by linefeeds

05AB1E， 4  3字节

已更新，因为更新œ破坏了旧版本，
并且还按Magic Octopus Urn的建议保存了一个字节。

œê»

在线尝试！

说明

œ     # get all permutations of input
 ê    # sort and remove duplicates
  »   # join list by newlines

MATL，4个字节

Y@Xu

在线尝试！

说明

Y@    % Implicit input. Push 2D array of all permutations, each on a row, sorted
Xu    % Unique rows. Implicitly display

Python 3.5，79个字节

def f(s,w=''):
 s or print(w)
 for c in sorted({*s}):t=s*1;t.remove(c);f(t,w+c)

将输入作为字符列表并通过打印输出的功能。

通过按字母顺序从剩余的不同字符中取出每个可能的下一个字符，并将其附加到进行中的输出中，以递归方式进行每个不同的排列w。然后，我们递归删除该字符。输入清空后，我们打印w。

CJam，5个字节

感谢@EriktheOutgolfer的更正（q而不是r）

qe!N*

在线尝试！

说明

q        e# Read input as a string
 e!      e# Unique permutations, sorted
   N*    e# Join by newline. Implicitly display

Pyth-5个字节

jS{.p

在这里在线尝试。

j        Join. Implictly joins on newlines.
 S       Sort
  {      Uniquify
   .p    All permutations, implicitly run on input.

Haskell，46个字节

import Data.List;unlines.sort.nub.permutations

感谢nimi，节省了2个字节

J，19个字节

/:~@~.@:{~!@#A.&i.#

测试用例

   f =: /:~@~.@:{~!@#A.&i.#
   f 'buzz'
buzz
bzuz
bzzu
ubzz
uzbz
uzzb
zbuz
zbzu
zubz
zuzb
zzbu
zzub

说明

这是4列火车：

                     /- ~ --- /:
               /- @ -^- ~.
  /- ~ --- @: -^- {
  |
  |            /- !
--<     /- @ --^- #
  |     |
  \-----<      /- A.
        >- & --^- i.
        \- #

基本上：

/:~@~.@:{~!@#A.&i.#
          !  A.&     get permutations
           @#   i.#  of range (0..length)
        {~           map indices to chars in string
      @:             then
    ~.               unique
   @                 then
/:~                  sort

JavaScript（Firefox 30 +），129 124字节

f=(a,i=-1)=>a[1]?[for(x of a.sort())if(a.indexOf(x)==++i)f([...a.slice(0,i),...a.slice(i+1)]).replace(/^/gm,x)].join`
`:a[0]

对于没有内置置换的语言来说，还算不错。

Python 3.5，81个字节：

from itertools import*;lambda i:'\n'.join(sorted({*map(''.join,permutations(i))}))

真的......当一个最长的答案是48个字节...... 81个字节的叹息。好吧，我将尽我所能尝试这种高尔夫，但是高尔夫技巧仍然非常值得赞赏。

另外，这是我可以在Python 2中以86个字节获得的最短的解决方案：

from itertools import*;lambda f:'\n'.join(sorted({''.join(i)for i in permutations(f)}))

显然在Python 2中，[*...]返回一个Syntax Error，并且由于permutationsreturn itertools.permutations object at 0x...，提取唯一排列的下一个最短方法（我知道）是使用{''.join(i)for i in permutations(f)}where f是输入字符串。

最后，请注意，这些都是lambda函数，因此必须以format调用print(<Function Name>(<Input String>))。

Mathematica，34个 23个字节

Print@@@Permutations@#&

输入必须是字符列表。

说明

Permutations@

查找输入的所有排列，排序和无重复。

Print@@@

一张一张地打印。

Brachylog，9个字节

:pfdo~@nw

在线尝试！

说明

:pf         Find all outputs of p - Permute with the main Input as input
   d        Remove Duplicates
    o       Order
     ~@n    Concatenate into a single string with linebreaks as separator
        w   Write to STDOUT

Perl 6的， 49  44个字节

字符串作为输入

*.comb.permutations.sort».join.squish.map: *.put

输入字符列表

*.permutations.sort».join.squish.map: *.put

展开式

*\              # Whatever lambda
# .comb\        # split into a list of characters
.permutations\  # returns a list of lists
.sort\
».join\         # join the second level lists
.squish\        # remove adjacent repeated values
.map: *.put     # print each on its own line

Brachylog（v2），5个字节

pᵘoẉᵐ

在线尝试！

查找ᵘNIQUE p输入ermutations，S o室温他们，ᵐAP ẉriteln（新行写）在该数组。

Python 3，77 85字节

现在排序！

import itertools as i
for a in sorted(set(i.permutations(input()))):print("".join(a))

PowerShell v3 +，171字节

param([char[]]$x)$a,$b=$x;$a=,$a;while($b){$z,$b=$b;$a+=$a|%{0..($y=($c="$_").Length)|%{-join($c[0..$_]+$z+$c[++$_..$y])};"$z$c";"$c$z"}}$a|?{$_.length-eq$x.count}|sort -u

PowerShell v3 -Unique在Sort-Objectcmdlet 上引入了该标志，因此它比下面的v2版本短了几个字节，因为我们不需要Select先这样做。

v2版本，178个字节：

param([char[]]$x)$a,$b=$x;$a=,$a;while($b){$z,$b=$b;$a+=$a|%{0..($y=($c="$_").Length)|%{-join($c[0..$_]+$z+$c[++$_..$y])};"$z$c";"$c$z"}}$a|?{$_.length-eq$x.count}|select -u|sort

PowerShell没有任何内置置换，因此我从Prime Factors Buddies借用了我的代码，并对其进行了一些微调以供在此使用。

这实际上是三个部分，我将在下面进行扩展。

param([char[]]$x)$a,$b=$x;$a=,$a接受输入$x，将其转换为char-array，将第一个字母剥离为$a，将其余的$b剥离$a为，然后使用逗号运算符将其重铸为数组。

while($b){$z,$b=$b;$a+=$a|%{0..($y=($c="$_").Length)|%{-join($c[0..$_]+$z+$c[++$_..$y])};"$z$c";"$c$z"}}循环遍历剩余的字母（$b），每次迭代都将下一个字母存储在剩余的字母$z中$b，然后将剩余的字母存储在其中，然后数组级联到通过其自己的循环$a发送的结果上$a-循环$a（暂时存储到$c）的每个项自己的.length，然后$z插入到每个位置，包括前面加上与附加$z$c和$c$z。例如，对于$c = '12'和$z = '3'，这将导致'132','312','123'被串联回$a。

最后一部分$a|?{$_.length-eq$x.count}|select -u|sort采用$aand Where-Object子句的每个元素，以仅过滤出与输入字符串长度相同的那些，然后select仅输入-unique项，最后sort按字母顺序对它们进行过滤。结果字符串将全部留在管道上，并Write-Output在程序完成时通过隐式输出。

PS C:\Tools\Scripts\golfing> .\alphabetically-permute-a-string.ps1 'PPCG'
CGPP
CPGP
CPPG
GCPP
GPCP
GPPC
PCGP
PCPG
PGCP
PGPC
PPCG
PPGC

JavaScript（ES6），119个字节

f=(s,t=[...s].sort().join``,p=``)=>t?t.replace(/./g,(c,i)=>t.indexOf(c)==i?f(s,t.slice(0,i)+t.slice(i+1),p+c):``):p+`\n`

其中\n代表文字换行符。@ETHproduction的答案使用字符串而不是数组。反转输出，或将尾随换行符移到开头，将节省3个字节。

R，113字节

x=scan(,"");cat(sort(unique(apply(matrix(x[permute:::allPerms(l<-length(x))],,l),1,paste,collapse=""))),sep="\n")

从标准输入读取输入。permute假定已安装该软件包以便调用该allPerms功能。

我下班回家时将添加一个解释。

Java 302300字节

import java.util.*;class M{public static void main(String[]a){for(Object s:p(new TreeSet(),"",a[0]))System.out.println(s);}static Set p(Set l,String p,String s){int n=s.length(),i=0;if(n>1)for(;i<n;p(l,p+s.charAt(i),s.substring(0,i)+s.substring(++i,n)));else if(!l.contains(p+=s))l.add(p);return l;}}

取消测试代码：

在这里尝试。

import java.util.*;
class M{
  static Set p(Set l, String p, String s){
    int n = s.length(),
        i = 0;
    if(n > 1){
      for(; i < n; p(l, p + s.charAt(i), s.substring(0, i) + s.substring(++i, n)));
    } else if(!l.contains(p+=s)){
      l.add(p);
    }
    return l;
  }

  public static void main(String[] a){
    for(Object s : p(new TreeSet(), "", a[0])){
      System.out.println(s);
    }
  }
}

输入：测试
输出：

estt
etst
etts
sett
stet
stte
test
tets
tset
tste
ttes
ttse

拍子82字节

(sort(remove-duplicates(map list->string(permutations(string->list s)))) string<?)

取消高尔夫：

(define(f s)
 (sort
  (remove-duplicates
   (map
    list->string
    (permutations
     (string->list s))))
  string<?))

测试：

(f "buzz")

输出：

'("buzz" "bzuz" "bzzu" "ubzz" "uzbz" "uzzb" "zbuz" "zbzu" "zubz" "zuzb" "zzbu" "zzub")

Groovy，69字节

{(it as List).permutations().unique().sort().each{println it.join()}}

Ruby，51个字节

->s{puts s.chars.permutation.map(&:join).uniq.sort}

实际上，8个字节

欢迎打高尔夫球！在线尝试！

;l@╨♂Σ╔i

开球

     Implicit input s.
;l   Get len(s).
@╨   Get all len(s)-length permutations of s.
♂Σ   Sum them all back into strings.
╔    uniq() the list of strings.
i    Flatten the list of strings.
     Implicit print the stack, separated by newlines.

点，8字节

7个字节的代码，-n标志+1 。

SSUQPMa

将字符串作为命令行参数。在线尝试！

Pip的扫描仪将大写字母分成两个字母大块。因此，此代码是SS UQ PM a--ie SortString(UniQue(PerMutations(a)))，并且a是命令行arg。该-n标志确保结果列表以换行符分隔。这里的所有都是它的。

K（oK），14个字节

解：

?x@<x@:prm@#x:

在线尝试！

说明：

使用内置的置换功能prm生成输入长度的置换，将这些置换应用于输入，按字母顺序排序，然后采用不同的值。

?x@<x@:prm@#x: / the solution
            x: / store input as x
           #   / count length of x
       prm@    / apply (@) function prm
    x@:        / apply indices to x and save result back into x
   <           / indices to sort ascending
 x@            / apply to x
?              / take distint

Perl -MList::Util=uniq -F 5、68个字节

$"=',';@b=sort@F;map{say if"@b"eq join$",sort/./g}uniq glob"{@b}"x@b

在线尝试！

Japt v2.0a0，5 -R个字节

á â n

试试吧

C ++（gcc），132128字节

#include<bits/stdc++.h>
using namespace std;int main(){string s;for(cin>>s;cout<<s<<endl,next_permutation(s.begin(),s.end()););}

在线尝试！

蛤，9字节

p_D`Sq@~Q

说明

          - Implicit Q = first input
p         - Print...
 _        - Sorted ascending value (alphabetical order)
  D       - Distinct from...
   `Sq    - Joined (map(q=>q.join(""))
      @~Q - Permutations of Q