Выведите «четные» перестановки симметрической группы Sn в циклических обозначениях


9

ЗАДАНИЕ

ОПРЕДЕЛЕНИЯ

Рассмотрим точки {1,2,3,4,5} и все их перестановки. Мы можем найти общее количество возможных перестановок этих 5 точек с помощью простого трюка: визуализация, заполняющая 5 слотов этими точками, у первого слота будет 5 возможных чисел, у второго 4 (так как один использовался для заполнения первого слота) третий 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->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 |

Поскольку ровно половина перестановок в любой симметрической группе является четной, мы можем назвать четную группу чередующейся группой 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)

И как в примерах, я хотел бы, чтобы все циклы одной длины были исключены, а также для идентичности: выходные данные ничего, (){не только в скобках, но с тем, что вы используете для показа различных перестановок} или idявляются приемлемыми.

ДОПОЛНИТЕЛЬНОЕ ЧТЕНИЕ

Вы можете найти больше информации здесь:

УДАЧИ

И поскольку это - кодовый гольф, тот, кто сможет напечатать перестановки группы переменных An в самых коротких байтах, выигрывает.


2
Добро пожаловать в Программирование головоломок и Code Golf! Обычно мы допускаем гибкость вывода, чтобы у языков, которые имеют проблемы с выводом в правильном формате, не было несправедливого недостатка. Разрешено ли выводить например [[1, 2], [3, 4]]вместо (1 2)(3 4)?
Аднан

@ Adnan Да, я должен был уточнить. Пока различные циклы показаны отдельно, не должно быть проблем с тем, как вы это представляли.
Гарри

«Четная» перестановка - это та, где существует четное число четных перестановок ». Это похоже на циклическое определение. Может быть, сначала ввести обозначение цикла, а затем переписать это предложение в «... четное число циклов четной длины»?
Мартин Эндер

Кроме того, как я могу поставить цикл (2 3 1 4)в порядке возрастания? Вы имеете в виду, что мы должны поместить самый маленький элемент впереди?
Мартин Эндер

@MartinEnder Да наименьший элемент должен идти первым, пока это не беспорядок с заказом, так (2 3 1 4)же 2->3->1->4->2она может быть записана (1 4 2 3)с наименьшим элементом первого
Гарри

Ответы:


5

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

Чтобы полностью изменить эту биекцию, мы можем взять любую перестановку в форме цикла, повернуть каждый цикл так, чтобы его наименьшее число было первым, отсортировать циклы так, чтобы их наименьшие числа появлялись в порядке убывания, и стереть все скобки.


OP требует, чтобы тождественная перестановка была представлена ​​без однократных циклов. Я думаю, что было бы лучше, если бы это было не так.
миль

1
Гарри, похоже, согласился с моим ответом на желе, который печатает 1 цикл даже для id. Может быть, он мог вмешаться?
Линн

Я не очень уверен в том, как это сформулировано, и я не заметил, что ваше решение (Линн) тоже сделало то же самое.
миль

Насколько я понимаю, вы не можете представить перестановку идентификаторов, используя пустую строку, поэтому я изменил свой ответ, чтобы сохранить все 1-циклы (также удобно экономя 6 байтов).
Нил

1
Я отредактировал свой вопрос, чтобы он был более понятным, и я хотел бы, чтобы «один цикл» был исключен, как вы сделали во второй части своего ответа. Молодцы кстати.
Гарри

6

Mathematica, 84 49 31 байт

GroupElements@*AlternatingGroup

Композиция двух функций. Выходы в виде {Cycles[{}], Cycles[{{a, b}}], Cycles[{{c, d}, {e, f}}], ...}представления (), (a b), (c d)(e f), ....


3

J , 53 байта

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

Циклы в каждой перестановке представлены в виде штучных массивов, поскольку J будет разбитыми массивами с нулевой подкладкой.

Если вывод ослаблен, используя 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│ │ │
└─────┴─┴─┘

Это на самом деле красиво ... хорошо сделано.
Гарри

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.

Я попытался запустить его с 5 в качестве входа, и не получил никакого вывода вообще. Это сценарий только для групп A3 и A4 или он может дать какую-либо группу? Я никогда раньше не видел Желе, поэтому любое объяснение было бы полезно.
Гарри

Нет, я поставил только 3 и 4 в вызове, так что пока вы выигрываете, но я просто хочу узнать больше.
Гарри

У желе на самом деле есть встроенный раздел, о котором я забыл! К счастью, друг напомнил мне. Так что теперь это более эффективно (обрабатывает n = 5, ура!) И короче.
Линн

ОП отредактировал вопрос, чтобы уточнить, что 1-циклы должны быть исключены.
Андерс Касеорг

2

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

Я не против, если формат не в идеальной циклической записи, если: каждая перестановка и ее циклы показаны отдельно (например, [1 2 3] [4 5] и << 123> <45 >> оба будут приемлемы ) и циклы одной длины исключаются. Возможно, это может сократить ваш ответ
Гарри

@ Гарри, я бы никогда не показал (1,2,3)(4,5)- это странная перестановка! В настоящее время я покажу, например, (1,2,3)(4)(5)- не только удаление циклов длиной один обойдется мне в 6 байтов, но затем я получу пустой результат для цикла идентификации, который будет стоить мне еще 4 байта для исправления.
Нил

Если вы имеете в виду, что ничего не напечатано для личности, то я приму это, как я сказал as for the identity outputs of nothing ... are accepatble. А также, что будет показано, если вы выведете свои «необработанные данные», они будут представлены в виде (1,2,3) (4) (5) или как-то еще?
Гарри

@Harry Теперь исключая циклы длины один, включая пустую запись для идентификатора, и все же удается сохранить байт!
Нил

@Harry Raw данные будут [1, 2, 0, 3, 4]для этого конкретного примера, так что далеко не так, как вы хотите.
Нил

1

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

Очень хорошее форматирование, я думаю, что GAP был очень хорошим выбором для решения этой проблемы.
Гарри

Ваш ответ не показывает, где заканчивается одна перестановка и начинается следующая. Предполагая, что функция не должна печатать значения как побочный эффект, но может просто возвращать значения в виде списка, который должен быть напечатан интерпретатором, я бы это сделалf:=n->List(AlternatingGroup(n));
Christian Sievers
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.