TUGAS

DEFINISI

Pertimbangkan poin {1,2,3,4,5} dan semua permutasi mereka. Kita dapat menemukan jumlah total kemungkinan permutasi dari 5 poin ini dengan trik sederhana: Imaging mengisi 5 slot dengan poin-poin ini, slot pertama akan memiliki 5 angka yang mungkin, 4 yang kedua (seperti yang telah digunakan untuk mengisi slot pertama) 3 ketiga dan seterusnya. Dengan demikian jumlah total Permutasi adalah 5 * 4 * 3 * 2 * 1; ini akan menjadi 5! permutasi atau 120 permutasi. Kita dapat menganggap ini sebagai grup simetris S5, dan kemudian Grup Simetri Sn akan memiliki n! or (n*n-1*n-2...*1)permutasi.

Permutasi "genap" adalah permutasi di mana ada jumlah genap dari siklus panjang genap. Paling mudah dipahami ketika ditulis dalam notasi siklik, misalnya (1 2 3)(4 5)permutasi 1->2->3->1dan 4->5->4dan memiliki satu siklus 3 panjang (1 2 3)dan satu siklus 2 panjang (4 5). Saat mengklasifikasikan permutasi sebagai ganjil atau genap kami mengabaikan siklus panjang ganjil dan mengatakan bahwa permutasi ini [ (1 2 3)(4 5)] ganjil karena memiliki bilangan ganjil {1} ​​dari siklus panjang genap. Bahkan contoh:

1. (1)(2 3)(4 5)= dua 2 siklus panjang | BAHKAN |
2. (1 2 3 4 5)= tidak ada siklus panjang | BAHKAN | * perhatikan bahwa jika tidak ada siklus panjang yang hadir maka permutasi adalah genap.

Contoh Aneh:

1. (1 2)(3 4 5)= satu siklus 2 panjang | GANJIL |
2. (1)(2 3 4 5)= satu siklus 4 panjang | GANJIL |

Tepatnya setengah dari permutasi dalam Grup Symmetric mana pun bahkan kita dapat memanggil grup genap sebagai Alternating Group N, Sehingga S5 = 120 A5 = 60 permutasi.

PEMBERITAHUAN

Permutasi, setidaknya untuk ini, harus ditulis dalam notasi siklik di mana setiap siklus dalam kurung yang berbeda dan setiap siklus berjalan dalam urutan menaik. Misalnya (1 2 3 4 5)tidak (3 4 5 1 2). Dan untuk siklus dengan angka tunggal, seperti: (1)(2 3 4)(5)titik tunggal / tetap dapat dikecualikan artinya (1)(2 3 4)(5) = (2 3 4). Tetapi identitas {titik di mana semua titik ditetapkan (1)(2)(3)(4)(5)} harus ditulis ()hanya untuk mewakilinya.

TANTANGAN

Saya ingin Anda, dalam kode sesedikit mungkin, mengambil bilangan bulat positif sebagai input {1,2,3,4 ...} dan menampilkan semua permutasi dari Alternating Group An di mana n adalah input / semua bahkan permutasi dari Sn. Sebagai contoh:

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

dan

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)

Dan seperti dalam contoh saya ingin semua siklus dari satu panjang untuk dieliminasi, dan untuk identitas: output apa - apa, (){tidak hanya tanda kurung tetapi dengan apa pun yang Anda gunakan untuk menunjukkan permutasi yang berbeda} atau iddapat diterima.

BACAAN EKSTRA

Anda dapat menemukan informasi lebih lanjut di sini:

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

SEMOGA BERHASIL

Dan karena ini adalah codegolf, siapa pun yang dapat mencetak permutasi Alternating Group An dalam byte terpendek, akan menang.

Pyth, 26 byte

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.

Cobalah online

Solusi ini didasarkan pada penataan yang rapi antara permutasi dalam notasi satu baris dan permutasi dalam notasi siklus. Tentu saja, ada anggapan jelas di mana kedua notasi tersebut mewakili permutasi yang sama:

[8, 4, 6, 3, 10, 1, 5, 9, 2, 7] = (1 8 9 2 4 3 6) (5 10 7)

tetapi itu akan mengambil terlalu banyak kode. Alih-alih, cukup potong notasi satu baris menjadi beberapa bagian sebelum semua angka yang lebih kecil dari semua pendahulunya, sebut siklus potongan ini, dan buat permutasi baru darinya.

[8, 4, 6, 3, 10, 1, 5, 9, 2, 7] ↦ (8) (4 6) (3 10) (1 5 9 2 7)

Untuk membalikkan bijih ini, kita dapat mengambil permutasi apa pun dalam bentuk siklus, memutar setiap siklus sehingga jumlah terkecilnya adalah yang pertama, mengurutkan siklus sehingga jumlah terkecilnya muncul dalam urutan menurun, dan menghapus semua tanda kurung.

Mathematica, 84 49 31 byte

GroupElements@*AlternatingGroup

Komposisi dua fungsi. Output dalam bentuk yang {Cycles[{}], Cycles[{{a, b}}], Cycles[{{c, d}, {e, f}}], ...}mewakili (), (a b), (c d)(e f), ....

J , 53 byte

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

Siklus di setiap permutasi diwakili sebagai array kotak karena J akan zero-pad array yang compang-camping.

Jika outputnya santai, gunakan 41 byte

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

di mana setiap permutasi dapat berisi satu siklus dan nol siklus.

Pemakaian

   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││
││└─────┘│└─────┘│└───┴───┘│└─────┘│└─────┘│└─────┘│└─────┘│└───┴───┘│└─────┘│└─────┘│└───┴───┘│
└┴───────┴───────┴─────────┴───────┴───────┴───────┴───────┴─────────┴───────┴───────┴─────────┘

Untuk implementasi alternatif,

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

Jelly , 34 28 byte

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

Coba di sini .

Penjelasan

Setiap baris dalam program Jelly mendefinisikan fungsi; yang paling bawah adalah " main".

• Baris pertama mendefinisikan fungsi yang menguji apakah suatu produk siklus aneh.

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

• Baris kedua menormalkan partisi permutasi [1…n]menjadi produk siklus sebagai berikut:

       µ€    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.
  

  Ini akan mengubah misalnya (4 3)(2 5 1)menjadi (1 2 5)(3 4).

Inilah program utamanya. Dibutuhkan argumen ndari baris perintah, dan:

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

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]]]

Sedihnya, 88 byte hanya cukup untuk menghasilkan grup bolak-balik sebagai daftar permutasi a, jadi saya perlu biaya tambahan 132 130 124 123 byte untuk mengkonversi output ke format yang diinginkan:

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)

Saya telah berhasil memotong versi ES6 saya ke 222 216 215 byte:

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 byte

Terima kasih kepada @ChristianSievers karena memotong hitungan menjadi dua.

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

Penggunaan saat diminta:

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) ]