Imprimer les permutations «paires» du groupe symétrique Sn en notation cyclique


9

LA TÂCHE

DÉFINITIONS

Considérez les points {1,2,3,4,5} et toutes leurs permutations. On peut trouver le nombre total de permutations possibles de ces 5 points par une simple astuce: Imaging remplissant 5 slots avec ces points, le premier slot aura 5 nombres possibles, le second 4 (comme on a été utilisé pour remplir le premier slot) le troisième 3 et ainsi de suite. Ainsi, le nombre total de permutations est de 5 * 4 * 3 * 2 * 1; ce serait 5! permutations ou 120 permutations. Nous pouvons penser à cela comme le groupe symétrique S5, puis le groupe symétrique Sn aurait des n! or (n*n-1*n-2...*1)permutations.

Une permutation "paire" est celle où il y a un nombre pair de cycles de longueur paire. Il est plus facile à comprendre lorsqu'il est écrit en notation cyclique, par exemple (1 2 3)(4 5)permute 1->2->3->1et 4->5->4et a un cycle de 3 longueur (1 2 3)et un cycle 2 de longueur (4 5). Lorsque nous classons une permutation comme impaire ou paire, nous ignorons les cycles de longueur impaires et disons que cette permutation [ (1 2 3)(4 5)] est impaire car elle a un nombre impair {1} de cycles de longueur paire. Même exemples:

  1. (1)(2 3)(4 5)= deux cycles de 2 longueurs | MÊME |
  2. (1 2 3 4 5)= pas de cycles de longueur pairs | MÊME | * notez que si aucun cycle de longueur paire n'est présent, alors la permutation est paire.

Exemples étranges:

  1. (1 2)(3 4 5)= un cycle de 2 longueurs | ODD |
  2. (1)(2 3 4 5)= un cycle de 4 longueurs | ODD |

Comme exactement la moitié des permutations dans un groupe symétrique sont paires, nous pouvons appeler le groupe pair le groupe alternatif N, de sorte que S5 = 120 A5 = 60 permutations.

NOTATION

Les permutations doivent, au moins pour cela, être écrites en notation cyclique où chaque cycle est entre parenthèses différentes et chaque cycle va dans l'ordre croissant. Par exemple (1 2 3 4 5)non (3 4 5 1 2). Et pour les cycles avec un seul numéro, tels que: (1)(2 3 4)(5)les points uniques / fixes peuvent être exclus, ce qui signifie (1)(2 3 4)(5) = (2 3 4). Mais l'identité {le point où tous les points sont fixes (1)(2)(3)(4)(5)} doit être écrite comme ()juste pour la représenter.

LE DÉFI

J'aimerais que vous, dans le moins de code possible, preniez n'importe quel entier positif comme entrée {1,2,3,4 ...} et affichez toutes les permutations du groupe alternatif An où n est l'entrée / tout le pair permutations de Sn. Par exemple:

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

et

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)

Et comme dans les exemples, je voudrais que tous les cycles d'une longueur soient élidés et que pour l'identité: sorties de rien, (){non seulement des crochets mais avec tout ce que vous utilisez pour afficher différentes permutations} ou idsont acceptables.

LECTURE SUPPLÉMENTAIRE

Vous pouvez trouver plus d'informations ici:

BONNE CHANCE

Et comme il s'agit de codegolf, quiconque peut imprimer les permutations du groupe alternatif An dans les octets les plus courts gagne.


2
Bienvenue dans Programmation d'énigmes et Code Golf! Normalement, nous permettons à la sortie d'être flexible, de sorte que les langues qui ont des problèmes avec la sortie dans le bon format n'aient pas un inconvénient injuste. Est-il autorisé à sortir par exemple [[1, 2], [3, 4]]au lieu de (1 2)(3 4)?
Adnan

@Adnan Oui, j'aurais dû clarifier. Tant que les différents cycles sont affichés séparément, il devrait y avoir aucun problème avec la façon dont vous avez représenté cela.
Harry

"Une permutation" paire "est celle où il y a un nombre pair de permutations paires." Cela ressemble à une définition cyclique. Peut-être introduire d'abord la notation des cycles, puis réécrire cette phrase en "... nombre pair de cycles de même longueur"?
Martin Ender

De plus, comment mettre le cycle (2 3 1 4)en ordre croissant? Voulez-vous dire que nous devrions simplement mettre le plus petit élément à l'avant?
Martin Ender

@MartinEnder Oui, le plus petit élément doit aller en premier tant qu'il ne dérange pas la commande, de (2 3 1 4)même 2->3->1->4->2qu'il peut être écrit (1 4 2 3)avec son plus petit élément en premier
Harry

Réponses:


5

Pyth, 26 octets

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.

Essayez-le en ligne

Cette solution est basée sur une bijection nette entre les permutations en notation d'une ligne et les permutations en notation de cycle. Bien sûr, il y a la bijection évidente où les deux notations représentent la même permutation:

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

mais cela prendrait trop de code. Au lieu de cela, coupez simplement la notation d'une ligne en morceaux avant tous les nombres plus petits que tous leurs prédécesseurs, appelez ces cycles de morceaux et construisez une nouvelle permutation à partir d'eux.

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

Pour inverser cette bijection, nous pouvons prendre n'importe quelle permutation sous forme de cycle, faire pivoter chaque cycle de sorte que son plus petit nombre soit le premier, trier les cycles afin que leurs plus petits nombres apparaissent dans l'ordre décroissant et effacer toutes les parenthèses.


L'OP nécessite que la permutation d'identité soit représentée sans un cycle. Je pense que ce serait mieux si ce n'était pas le cas.
miles

1
Harry semblait d'accord avec ma réponse Jelly, qui imprime même 1 cycle id. Peut-être qu'il pourrait sonner?
Lynn

Je ne suis pas trop sûr de la façon dont il est libellé, et je n'ai pas remarqué que votre solution (Lynn's) faisait de même.
miles

Ma compréhension était que vous ne pouviez pas représenter la permutation d'identité en utilisant la chaîne vide, j'ai donc modifié ma réponse pour garder tous les 1-cycles (économisant également 6 octets).
Neil

1
J'ai édité ma question pour qu'elle soit plus claire, j'aimerais que les «un cycles» soient élidés comme vous l'avez fait dans la deuxième partie de votre réponse. Bravo au fait.
Harry

6

Mathematica, 84 49 31 octets

GroupElements@*AlternatingGroup

Composition de deux fonctions. Sorties sous la forme {Cycles[{}], Cycles[{{a, b}}], Cycles[{{c, d}, {e, f}}], ...}représentant (), (a b), (c d)(e f), ....


3

J , 53 octets

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

Les cycles de chaque permutation sont représentés sous forme de tableaux en boîte, car J mettra à zéro les tableaux en lambeaux.

Si la sortie est détendue, en utilisant 41 octets

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

où chaque permutation peut contenir un cycle et un cycle zéro.

Usage

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

Pour la mise en œuvre alternative,

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

C'est vraiment beau ... bravo.
Harry

2

Gelée , 34 28 octets

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

Essayez-le ici .

Explication

Chaque ligne d'un programme Jelly définit une fonction; celui du bas est « main».

  • La première ligne définit une fonction qui teste si un produit de cycle est impair.

    L€      Length of each
      ’     Add 1 to each length 
       S    Take the sum
        Ḃ   Modulo 2
    
  • La deuxième ligne normalise une partition d'une permutation de [1…n]en un produit de cycle comme suit:

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

    Cela se transformera par exemple (4 3)(2 5 1)en (1 2 5)(3 4).

Voici le programme principal. Il prend un argument nde la ligne de commande et:

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

J'ai essayé de l'exécuter avec 5 en entrée et je n'ai obtenu aucune sortie. Ce script est-il uniquement destiné aux groupes A3 et A4 ou peut-il potentiellement donner à n'importe quel groupe? Je n'ai jamais vu Jelly auparavant, donc toute explication serait utile.
Harry

Non, je ne mets que 3 et 4 dans le défi donc, jusqu'à présent, vous gagnez mais je veux vraiment en savoir plus.
Harry

Jelly a en fait un intégré pour les partitions, que j'ai oublié! Heureusement, un ami m'a rappelé. Alors maintenant, il est plus efficace (gère n = 5, yay!) Et plus court.
Lynn

OP a modifié la question pour préciser que les cycles 1 doivent être élidés.
Anders Kaseorg

2

JavaScript (Firefox 30-57), 220 218 212 212 211 octets

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

Malheureusement, 88 octets ne suffisent que pour générer le groupe alternatif sous forme de liste de permutations a, il me coûte donc 132 130 124 123 octets supplémentaires pour convertir la sortie au format souhaité:

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)

J'ai réussi à réduire ma version ES6 à 222 216 215 octets:

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

Cela ne me dérange pas si le format n'est pas en notation cyclique parfaite tant que: chaque permutation et ses cycles sont affichés séparément (comme [1 2 3] [4 5] et <<123> <45>> seraient tous deux acceptables ) et les cycles d'une longueur sont supprimés. Peut-être que cela peut raccourcir votre réponse
Harry

@ Harry, je ne montrerais jamais (1,2,3)(4,5)- c'est une étrange permutation! Actuellement, je montrerais par exemple (1,2,3)(4)(5)- non seulement la suppression des cycles de la première longueur me coûte 6 octets, mais je me retrouve avec un résultat vide pour le cycle d'identité qui me coûterait encore 4 octets à corriger.
Neil

Si vous voulez dire que rien n'est imprimé pour l'identité, je l'accepterai comme je l'ai dit as for the identity outputs of nothing ... are accepatble. Et aussi ce qui serait affiché si vous sortez vos "données brutes", cela vient-il sous la forme (1,2,3) (4) (5) ou autre chose?
Harry

@Harry Excluant maintenant les cycles de longueur un, y compris une entrée vide pour l'identité, et réussissant toujours à enregistrer un octet!
Neil

@Harry Les données brutes seraient [1, 2, 0, 3, 4]pour cet exemple particulier, donc loin de ce que vous voulez.
Neil

1

GAP , 32 octets

Merci à @ChristianSievers d'avoir réduit de moitié le nombre.

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

Utilisation à l'invite:

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

Formatage très agréable, je pense que GAP était un très bon choix pour répondre à ce problème.
Harry

Votre réponse ne montre pas où se termine une permutation et la suivante commence. En supposant que la fonction n'a pas besoin d'imprimer les valeurs comme effet secondaire, mais peut simplement renvoyer les valeurs sous forme de liste à imprimer par l'interpréteur, je le feraisf:=n->List(AlternatingGroup(n));
Christian Sievers
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.