งาน

บทนิยาม

พิจารณาคะแนน {1,2,3,4,5} และการเรียงลำดับทั้งหมด เราสามารถหาจำนวนทั้งหมดของการเปลี่ยนลำดับที่เป็นไปได้ของ 5 คะแนนด้วยเคล็ดลับง่ายๆ: การถ่ายภาพเติม 5 ช่องด้วยคะแนนเหล่านี้ช่องแรกจะมี 5 หมายเลขที่เป็นไปได้ 4 อันดับสอง (เนื่องจากมีการใช้เพื่อเติมช่องแรก) 3 ที่สามเป็นต้น ดังนั้นจำนวนพีชคณิตทั้งหมดคือ 5 * 4 * 3 * 2 * 1; นี่จะเป็น 5! พีชคณิตหรือ 120 พีชคณิต เราสามารถคิดได้ว่านี่เป็นกลุ่มสมมาตร S5 จากนั้น Symmetric Group Sn จะมีn! or (n*n-1*n-2...*1)การเรียงสับเปลี่ยน

การเปลี่ยนรูปแบบ "คู่" คือหนึ่งที่มีจำนวนรอบความยาวเท่ากัน มันเป็นเรื่องง่ายที่จะเข้าใจเมื่อเขียนในสัญกรณ์วงจรเช่น(1 2 3)(4 5)permutes 1->2->3->1และ4->5->4มีหนึ่งรอบ 3 ความยาวและความยาวรอบ(1 2 3) 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)= วงจรความยาวหนึ่ง 2 ODD |
2. (1)(2 3 4 5)= หนึ่งความยาว 4 รอบ | ODD |

ครึ่งหนึ่งของการเปลี่ยนลำดับในกลุ่ม Symmetric ใด ๆ ถึงแม้เราจะสามารถเรียกกลุ่มสำรองกลุ่ม N ได้ดังนั้น S5 = 120 A5 = 60 การเปลี่ยนลำดับ

NOTATION

อย่างน้อยที่สุดการเรียงสับเปลี่ยนควรเขียนด้วยเครื่องหมายวงกลมที่แต่ละรอบอยู่ในวงเล็บที่แตกต่างกันและแต่ละรอบจะเรียงตามลำดับจากน้อยไปมาก ยกตัวอย่างเช่นไม่ได้(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 ... } และแสดงการเรียงสับเปลี่ยนทั้งหมดของ Alternating Group 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)

และเช่นเดียวกับในตัวอย่างที่ฉันต้องการสำหรับทุกรอบของหนึ่งในระยะเวลาที่จะ elided และเป็นเอกลักษณ์นี้: ผลของอะไร(){ไม่เพียง แต่วงเล็บ แต่กับสิ่งที่คุณใช้ในการแสดงที่แตกต่างกันพีชคณิต} หรือidเป็นที่ยอมรับ

การอ่านพิเศษ

คุณสามารถหาข้อมูลเพิ่มเติมได้ที่นี่:

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

โชคดี

และนี่คือ codegolf ใครก็ตามที่สามารถพิมพ์สลับสับเปลี่ยนของกลุ่ม Alternating ในไบต์ที่สั้นที่สุดชนะ

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) (3 6) (3 10) (1 5 9 2 7)

ในการย้อนกลับ bijection นี้เราสามารถใช้การเปลี่ยนแปลงใด ๆ ในรูปแบบวงจรหมุนแต่ละรอบดังนั้นจำนวนที่เล็กที่สุดของมันเป็นครั้งแรกจัดเรียงรอบเพื่อให้ตัวเลขที่เล็กที่สุดของพวกเขาปรากฏในลำดับที่ลดลงและลบวงเล็บทั้งหมด

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 จะอาร์เรย์แบบ ragged zero-pad

หากเอาต์พุตผ่อนคลายให้ใช้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 (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) ]