タスク

定義

ポイント{1,2,3,4,5}とそれらのすべての順列を考慮してください。これらの5つのポイントの可能な順列の総数は、簡単なトリックで確認できます。5つのスロットをこれらのポイントで埋めるイメージ、最初のスロットは5つの可能な数字、2番目のスロットは4つ（最初のスロットを埋めるために使用されているため） 3番目の3など。したがって、順列の総数は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->43つの長さのサイクル(1 2 3)と2つの長さのサイクルが1つずつあります(4 5)。順列を奇数または偶数として分類する場合、奇数長のサイクルを無視し、この順列[ (1 2 3)(4 5)]は奇数であると言います。例でも：

1. (1)(2 3)(4 5)= 2つの2長さサイクル| EVEN |
2. (1 2 3 4 5)=長さのサイクルはありません| EVEN | *長さのサイクルが存在しない場合、順列は偶数であることに注意してください。

奇妙な例：

1. (1 2)(3 4 5)= 1つの2長さサイクル| ODD |
2. (1)(2 3 4 5)= 1つの4長さサイクル| ODD |

対称グループの順列のちょうど半分が偶数であるため、偶数グループを交互グループ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)

また、例と同様に、1つの長さのすべてのサイクルを省略し、IDについては何も出力しない、(){ブラケットだけでなく、さまざまな順列を示すために使用してidいるもの}または許容できるものを出力します。

追加の読書

あなたはここでより多くの情報を見つけることができます：

• https://en.wikipedia.org/wiki/Permutation
• https://en.wikipedia.org/wiki/Alternating_group

幸運を

これはcodegolfなので、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.

オンラインでお試しください

このソリューションは、1行表記の順列とサイクル表記の順列の間の端正な全単射に基づいています。もちろん、2つの表記が同じ順列を表す明らかな全単射があります。

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

しかし、それではコードが多すぎます。代わりに、すべての先行バージョンよりも小さいすべての数値の前に1行表記を断片に切り、これらの断片を循環と呼び、それらから新しい順列を構築します。

[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

2つの機能の構成。を{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.]

ここで、各置換には1サイクルと0サイクルが含まれます。

使用法

   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」です。

• 1行目は、サイクル積が奇数かどうかをテストする関数を定義しています。

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

• 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（Firefox 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) ]