任务

定义

考虑点{1,2,3,4,5}及其所有排列。我们可以通过一个简单的技巧找到这5个点的可能排列总数：成像用这些点填充5个插槽，第一个插槽将具有5个可能的数字，第二个插槽将具有5个可能的数字（因为已经使用一个填充了第一个插槽）第三三个，依此类推。因此，置换的总数为5 * 4 * 3 * 2 * 1；这将是5！排列或120个排列。我们可以将其视为对称组S5，然后对称组Sn将具有n! or (n*n-1*n-2...*1)置换。

“偶数”排列是偶数个偶数长度周期的排列。以循环表示法（例如(1 2 3)(4 5)置换）书写时最容易理解1->2->3->1，4->5->4并且具有1个3个长度的周期(1 2 3)和1个2个长度的周期(4 5)。当将排列归类为奇数或偶数时，我们忽略奇数长度的循环，并说此排列[ (1 2 3)(4 5)]为奇数，因为它具有偶数长度循环的奇数{1}。甚至示例：

1. (1)(2 3)(4 5)=两个2长度循环| 偶数
2. (1 2 3 4 5)=没有均匀的长度循环| 偶数 *请注意，如果不存在偶数长度循环，则排列是偶数。

奇怪的例子：

1. (1 2)(3 4 5)= 1个2个长度周期| 奇数|
2. (1)(2 3 4 5)= 1个4个长度的周期| 奇数|

由于在任何对称组中恰好一半的排列是偶数，因此我们可以将偶数组称为交替组N，因此S5 = 120 A5 = 60排列。

符号

至少为此，应使用循环符号来编写排列，其中每个循环使用不同的括号，并且每个循环以升序排列。例如(1 2 3 4 5)没有(3 4 5 1 2)。对于具有单个数字的循环，例如：(1)(2 3 4)(5)可以排除单个/固定点的含义(1)(2 3 4)(5) = (2 3 4)。但是标识（所有点都固定的点(1)(2)(3)(4)(5)）应该写成()只是用来表示它。

挑战

我希望您以尽可能少的代码将任何正整数作为输入{1,2,3,4 ...}并显示交替组An的所有排列，其中n是输入/偶数Sn的排列 例如：

Input = 3
()
(1 2 3)
(1 3 2)

和

Input = 4
()
(1 2)(3 4)
(1 3)(2 4)
(1 4)(2 3)
(1 2 3)
(1 3 2)
(1 2 4)
(1 4 2)
(1 3 4)
(1 4 3)
(2 3 4)
(2 4 3)

就像在示例中一样，我希望消除一个长度的所有周期，并且对于标识：什么也不输出，(){不仅是括号，而且无论您使用什么来显示不同的排列}，还是id可以接受的。

额外阅读

您可以在这里找到更多信息：

• https://zh.wikipedia.org/wiki/排列
• https://zh.wikipedia.org/wiki/Alternating_group

祝好运

因为这是代码高尔夫球员，所以谁可以在最短的字节中打印出交替组An的排列就赢了。

Pyth，26个字节

t#Mf%+QlT2mcdf<>dTS<dTd.pS

          m            .pSQ   Map over permutations d of [1, …, Q]:
             f        d         Find all indices T in [1, …, Q] such that
               >dT                the last Q-T elements of d
              <   S<dT            is less than the sorted first T elements of d
           cd                   Chop d at those indices
   f                          Filter on results T such that
      Q                         the input number Q
     + lT                       plus the length of T
    %    2                      modulo 2
                                is truthy (1)
t#M                           In each result, remove 0- and 1-cycles.

在线尝试

此解决方案基于单行表示法的排列与周期表示法的排列之间的整齐双射。当然，存在明显的双射，其中两个符号表示相同的排列：

[8，4，6，3，10，1，5，9，2，7] =（1 8 9 2 4 3 6）（5 10 7）

但这会花费太多代码。取而代之的是，简单地将单行符号切成小块，然后将所有小于其所有前任数字的数字称为这些块循环，并根据它们建立新的排列。

[8，4，6，3，10，1，5，9，2，7]↦（8）（4 6）（3 10）（1 5 9 2 7）

要逆转这种双射，我们可以采用周期形式的任何置换，旋转每个周期以使其最小的数字为第一，对周期进行排序以使其最小的数字以降序显示，并消除所有括号。

Mathematica，84 49 31字节

GroupElements@*AlternatingGroup

两个功能的组成。以{Cycles[{}], Cycles[{{a, b}}], Cycles[{{c, d}, {e, f}}], ...}表示形式的输出(), (a b), (c d)(e f), ...。

J，53字节

[:(<@((>:@|.~]i.<./)&.>@#~1<#@>)@C.@#~1=C.!.2)!A.&i.]

由于J将零填充的锯齿状数组零填充，所以每个置换中的循环都表示为方框数组。

如果输出是宽松的，则使用41个字节

[:((1+]|.~]i.<./)&.>@C.@#~1=C.!.2)!A.&i.]

其中每个排列可能包含一个周期和零个周期。

用法

   f =: [:(<@((>:@|.~]i.<./)&.>@#~1<#@>)@C.@#~1=C.!.2)!A.&i.]
   f 3
┌┬───────┬───────┐
││┌─────┐│┌─────┐│
│││1 2 3│││1 3 2││
││└─────┘│└─────┘│
└┴───────┴───────┘
   f 4
┌┬───────┬───────┬─────────┬───────┬───────┬───────┬───────┬─────────┬───────┬───────┬─────────┐
││┌─────┐│┌─────┐│┌───┬───┐│┌─────┐│┌─────┐│┌─────┐│┌─────┐│┌───┬───┐│┌─────┐│┌─────┐│┌───┬───┐│
│││2 3 4│││2 4 3│││1 2│3 4│││1 2 3│││1 2 4│││1 3 2│││1 3 4│││1 3│2 4│││1 4 2│││1 4 3│││2 3│1 4││
││└─────┘│└─────┘│└───┴───┘│└─────┘│└─────┘│└─────┘│└─────┘│└───┴───┘│└─────┘│└─────┘│└───┴───┘│
└┴───────┴───────┴─────────┴───────┴───────┴───────┴───────┴─────────┴───────┴───────┴─────────┘

对于其他实现，

   f =: [:((1+]|.~]i.<./)&.>@C.@#~1=C.!.2)!A.&i.]
   f 3
┌─────┬─┬─┐
│1    │2│3│
├─────┼─┼─┤
│1 2 3│ │ │
├─────┼─┼─┤
│1 3 2│ │ │
└─────┴─┴─┘

果冻，34 28 字节

L€’SḂ
ṙLR$Ṃµ€Ṣ
Œ!ŒṖ€;/Ç€ÑÐḟQ

在这里尝试。

说明

Jelly程序中的每一行都定义一个函数。底部的是“ main”。

• 第一行定义了一个测试循环乘积是否为奇数的函数。

  L€      Length of each
    ’     Add 1 to each length 
     S    Take the sum
      Ḃ   Modulo 2
  

• 第二行将的置换分区归一[1…n]化为循环乘积，如下所示：

       µ€    For each list X in the partition:
  ṙLR$          Rotate X by each element in [1…length(X)].
      Ṃ         Get the lexicographically smallest element.
                Thus, find the rotation so that the smallest element is in front.
         Ṣ   Sort the cycles in the partition.
  

  这将(4 3)(2 5 1)变成(1 2 5)(3 4)。

这是主程序。它n从命令行获取一个参数，并且：

Œ!              Compute all permutations of [1…n].
  ŒṖ€           Compute all partitions of each permutation.
     ;/         Put them in one big list.
       ǀ       Normalize each of them into a cycle product.
         ÑÐḟ    Reject elements satisfying the top function,
                i.e. keep only even cycle products.
            Q   Remove duplicates.

的JavaScript（火狐30-57），220个 218 212 211字节

f=(a,p)=>a[2]?[for(i of a)for(j of f(a.filter(m=>m!=i),p,p^=1))[i,...j]]:[[a[p],a[p^1]]]

不幸的是88个字节仅足以产生交替分组作为排列的列表a，所以它然后费用我的附加132个 130 124个 123字节到输出转换为所需的格式：

n=>f([...Array(n).keys()],0).map(a=>a.map((e,i)=>{if(e>i){for(s+='('+-~i;e>i;[a[e],e]=[,a[e]])s+=','+-~e;s+=')'}},s='')&&s)

我已经成功地修剪我ES6版降至222个 216 215字节：

n=>(g=(a,p,t=[])=>a[2]?a.map(e=>g(a.filter(m=>m!=e),p,[...t,e],p^=1)):[...t,a[p],a[p^1]].map((e,i,a)=>{if(e>i){for(s+='('+-~i;e>i;[a[e],e]=[,a[e]])s+=','+-~e;s+=')'}},s='')&&r.push(s))([...Array(n).keys(r=[])],0)&&r

GAP，32字节

感谢@ChristianSievers将数量减少了一半。

f:=n->List(AlternatingGroup(n));

提示符下的用法：

gap> f(4);
[ (), (1,3,2), (1,2,3), (1,4,3), (2,4,3), (1,3)(2,4), (1,2,4), (1,4)(2,3), (2,3,4), (1,3,4), (1,2)(3,4), (1,4,2) ]