GÖREV

TANIMLAR

{1,2,3,4,5} noktalarını ve bunların tüm permütasyonlarını düşünün. Bu 5 noktanın toplam olası permütasyon sayısını basit bir numarayla bulabiliriz: 5 yuvayı bu noktalarla doldurarak görüntüleme, ilk yuva 5 olası sayıya, ikinci 4'e (biri ilk yuvayı doldurmak için kullanıldığından) üçüncü 3 vb. Böylece toplam Permütasyon sayısı 5 * 4 * 3 * 2 * 1'dir; bu 5 olurdu! permütasyon veya 120 permütasyon. Bunu simetrik S5 grubu olarak düşünebiliriz ve sonra Simetrik Grup Sn n! or (n*n-1*n-2...*1)permütasyonlara sahip olur .

"Eşit" permütasyon, eşit sayıda çift uzunluk döngüsü olan bir permütasyondur. Bu, örneğin, siklik şeklinde yazılır zaman anlamak kolay olan (1 2 3)(4 5)permütasyon kodunun değiştirilmesini içerir 1->2->3->1ve 4->5->4ve bir 3 uzunlukta döngüsüne sahiptir (1 2 3)ve bir 2 uzunlukta döngüsü (4 5). Bir permütasyonu tek veya çift olarak sınıflandırırken, tek uzunluk döngülerini yok sayarız ve bu permütasyonun [ (1 2 3)(4 5)], tek uzunluk döngülerinin tek bir {1} sayısına sahip olduğu için garip olduğunu söyleriz . Hatta örnekler:

1. (1)(2 3)(4 5)= iki 2 uzunluk döngüsü | EVEN |
2. (1 2 3 4 5)= eşit uzunluk döngüsü yok | EVEN | * çift uzunluk döngüsü yoksa, permütasyonun çift olduğunu unutmayın.

Tek Örnekler:

1. (1 2)(3 4 5)= bir 2 uzunluk döngüsü | ODD |
2. (1)(2 3 4 5)= bir 4 uzunluk döngüsü | ODD |

Herhangi bir Simetrik Gruptaki permütasyonların tam yarısı olduğu için çift gruba bile Alternatif Grup N diyebiliriz, S5 = 120 A5 = 60 permütasyon olarak.

NOTASYONU

Permütasyonlar, bunun için en azından, her bir döngünün farklı parantez içinde olduğu ve her bir döngünün artan sırada olduğu döngüsel gösterimde yazılmalıdır. Örneğin (1 2 3 4 5)değil (3 4 5 1 2). Ve tek bir sayıya sahip olan döngüler için, örneğin: (1)(2 3 4)(5)tek / sabit noktaların anlamı hariç tutulabilir (1)(2 3 4)(5) = (2 3 4). Ancak kimlik (tüm noktaların sabit olduğu nokta), onu temsil edecek (1)(2)(3)(4)(5)şekilde yazılmalıdır ().

MEYDAN OKUMA

Mümkün olan en az kodda, herhangi bir pozitif tamsayıyı {1,2,3,4 ...} girişi olarak almanızı ve Alternatif Grup Anının tüm permütasyonlarını görüntülemenizi istiyorum, burada n, giriş / tüm Sn permütasyonları. Örneğin:

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

ve

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)

Ve örneklerde olduğu gibi, bir uzunluktaki tüm döngülerin elenmesini ve kimliğe gelmesini istiyorum: hiçbir şeyin çıktıları , (){sadece parantezler değil, farklı permütasyonlar göstermek için kullandığınız her şeyle} veya idkabul edilebilir.

EKSTRA OKUMA

Daha fazla bilgiyi burada bulabilirsiniz:

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

İYİ ŞANSLAR

Ve bu Codegolf olduğundan, Alternatif Grup An'ın permütasyonlarını en kısa baytta basabilen herkes kazanır.

Pyth, 26 bayt

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.

Çevrimiçi deneyin

Bu çözüm, tek satırlı gösterimdeki permütasyonlar ile döngü gösterimindeki permütasyonlar arasında düzgün bir bijeksiyona dayanmaktadır. Tabii ki, iki gösterimin aynı permütasyonu temsil ettiği bariz bir ayrım var:

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

ama bu çok fazla kod gerektiriyordu. Bunun yerine, tek satırlık gösterimi, öncekilerden daha küçük olan tüm sayılardan önce parçalara ayırın, bu parça döngülerini çağırın ve bunlardan yeni bir permütasyon oluşturun.

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

Bu seçimleri tersine çevirmek için, döngü biçiminde herhangi bir permütasyon alabilir, her döngüyü en küçük sayı ilk olacak şekilde döndürebilir, döngüleri en küçük sayıları azalan sırada görünecek şekilde sıralayabilir ve tüm parantezleri silebiliriz.

Mathematica, 84 49 31 bayt

GroupElements@*AlternatingGroup

İki fonksiyonun bileşimi. Çıktıları {Cycles[{}], Cycles[{{a, b}}], Cycles[{{c, d}, {e, f}}], ...}temsil eden biçimde çıktılar (), (a b), (c d)(e f), ....

J , 53 bayt

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

Her bir permütasyondaki döngüler kutulu diziler olarak temsil edilir, çünkü J sıfır pedli düzensiz dizileri olacaktır.

Çıktı gevşetilirse, 41 bayt kullanılarak

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

burada her permütasyon bir döngü ve sıfır döngü içerebilir.

kullanım

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

Alternatif uygulama için,

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

Jöle , 34 28 bayt

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

Burada deneyin .

açıklama

Bir Jelly programındaki her satır bir işlevi tanımlar; en alttaki " main".

• İlk satır, bir döngü ürününün garip olup olmadığını test eden bir işlevi tanımlar.

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

• İkinci satır, bir permütasyonun [1…n]bir döngü ürününe bölünmesini aşağıdaki gibi normalleştirir :

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

  Bu örneğin dönecek (4 3)(2 5 1)içine (1 2 5)(3 4).

İşte ana program. nKomut satırından bir argüman alır ve:

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

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

Ne yazık ki 88 bayt, sadece alternatif grubu bir permütasyon listesi olarak oluşturmak için yeterlidir a, bu yüzden çıktıyı istenen formata dönüştürmek için ek bir 132 130 124 123 bayt maliyeti :

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 sürümümü 222 216 215 bayta indirmeyi başardım :

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 bayt

Sayıyı yarıya indirdiği için @ChristianSievers'a teşekkürler.

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

Komut isteminde kullanım:

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