Permutazioni coniugate

17

Una permutazione di dimensione n è un riordino dei primi n numeri interi positivi. (significa che ogni numero intero appare una volta ed esattamente una volta). Le permutazioni possono essere trattate come funzioni che cambiano l'ordine di un elenco di elementi di dimensione n . Per esempio

(4 1 2 3) ["a", "b", "c", "d"] = ["d", "a", "b", "c"]

Quindi le permutazioni possono essere composte come funzioni.

(4 1 2 3)(2 1 3 4) = (4 2 1 3)

Ciò comporta molte proprietà interessanti. Oggi ci stiamo concentrando sulla coniugazione . Permutazioni y ed x (entrambi dimensione n ) sono coniugati sse ci sono permutazioni g e g -1 (anche di dimensione n ) tale che

x = gyg-1

e gg -1 è uguale alla permutazione dell'identità (i primi n numeri nell'ordine corretto).

Il tuo compito è prendere due permutazioni della stessa dimensione tramite metodi di input standard e decidere se sono coniugati. Dovresti generare uno di due valori coerenti, uno se sono coniugati e l'altro se non lo sono.

Questo è code-golf, quindi le risposte verranno classificate in byte con un numero inferiore di byte migliori.

Ci sono molti teoremi sulle permutazioni coniugate che sono a vostra disposizione, quindi buona fortuna e buon golf.

Puoi prendere l'input come contenitore ordinato di valori (1-n o 0-n) che rappresenta la permutazione come sopra, o come una funzione che prende un contenitore ordinato ed esegue la permutazione. Se scegli di assumere la funzione, dovresti prenderlo come argomento anziché averlo con un nome predefinito.

Casi test

(1) (1) -> True
(1 2) (2 1) -> False
(2 1) (2 1) -> True
(4 1 3 2) (4 2 1 3) -> True
(3 2 1 4) (4 3 2 1) -> False 
(2 1 3 4 5 7 6) (1 3 2 5 4 6 7) -> True
code-golf  decision-problem  combinatorics  permutations  abstract-algebra 
— Post Rock Garf Hunter
fonte
Possiamo prendere input come funzione? Possiamo anche prendere la taglia n?
— xnor
@xnor Sicuro su entrambi i fronti. Non sono sicuro di come il primo ti aiuterà però.
— Post Rock Garf Hunter,
Le regole di input della funzione predefinita consentono di presumere che la funzione sia predefinita, il che consente di risparmiare byte scrivendola come argomento, se lo si consente.
— xnor
@xnor Stiamo parlando di questa regola? Questo è per le funzioni della scatola nera che non sono permutazioni. Questo ha senso perché quel consenso è progettato per consentire alle lingue senza puntatori / oggetti di funzione di competere mentre qui possono perché le permutazioni possono essere rappresentate diversamente.
— Post Rock Garf Hunter,
Ero, non pensavo alla distinzione che fossero black-box. Quindi qui l'input può essere una funzione, ma solo come argomento esplicito?
— xnor

Risposte:

6

Python 2 , 87 byte

f=lambda P,k:k<1or len({sum([x==eval('L['*k+'x'+']'*k)for x in L])for L in P})&f(P,k-1)

Provalo online!

Prende input con Puna coppia di entrambe le permutazioni e la kloro lunghezza. Uscite 1per coniugati e 0non.

Questo utilizza il risultato:

Due permutazioni x ed y sono coniugati esattamente se la loro k poteri -esimo x k e y k hanno un numero uguale di punti fissi per ogni k da 0 a n .

Due permutazioni coniugate soddisfano questo perché anche i loro poteri k -esimo sono coniugati e la coniugazione preserva il conteggio dei punti fissi.

È meno ovvio che ogni due permutazioni non coniugate differiscono sempre. In particolare, la coniugazione è determinata dall'elenco ordinato delle lunghezze del ciclo e queste possono essere recuperate dai conteggi dei punti fissi. Un modo per dimostrarlo è con l'algebra lineare, anche se potrebbe essere eccessivo.

Sia X la matrice di permutazione per x . Quindi, il numero di punti fissi di x k è Tr (X k ) . Queste tracce sono i polinomi simmetrici della somma di potenza degli autovalori di X k con molteplicità. Questi polinomi per k da 0 a n ci permettono di recuperare i corrispondenti polinomi simmetrici elementari di questi autovalori, e quindi il polinomio caratteristico e quindi gli autovalori stessi.

Poiché questi autovalori sono radici di unità corrispondenti ai cicli di x , da questi possiamo recuperare le dimensioni del ciclo e le loro molteplicità. Quindi, la nostra "firma" identifica la permutazione fino alla coniugazione.

— XNOR
fonte
6

J , 25 byte 23 byte 16 byte

miglia tacita soluzione:

-:&([:/:~#&>)&C.

La soluzione esplicita di OP:

c=:4 :'-://:~"1#&>C.&>x;y'

Questo controlla se le permutazioni xey hanno lo stesso tipo di ciclo, usando la C.funzione integrata per produrre rappresentazioni del ciclo.

   4 1 3 2   c   4 2 1 3
1
   3 2 1 4   c   4 3 2 1
0
   2 1 3 4 5 7 6   c   1 3 2 5 4 6 7
1
— Mathias Dolidon
fonte
1
Benvenuti in PPCG e bel primo post. Ho abbreviato il tuo metodo a 16 byte -:&([:/:~#&>)&C.usando un modulo tacito. Ecco un link TIO per provarlo.
— miglia
Grazie. :) Sono ancora abbastanza alle prime armi con J, e sebbene sembri facilmente sfruttarlo con forme esplicite, comporre forme tacite efficienti richiede ancora un eccessivo pensiero per me. Aggiungerò la tua soluzione.
— Mathias Dolidon,
PS: non contiamo anche i caratteri delle assegnazioni di funzioni? c=:
— Mathias Dolidon,
1
@MathiasDolidon No, per impostazione predefinita, non contiamo i caratteri richiesti per l'assegnazione, poiché la funzione può essere utilizzata così com'è (tra parentesi, ma non li contiamo).
— Erik the Outgolfer,
1
OK ! Ho aggiornato retroattivamente i conteggi per la soluzione esplicita nel titolo per tenerne conto.
— Mathias Dolidon,
4

MATL , 20 19 17 16 byte

xY@!"&G@)@b)X=va

Input: due vettori di colonna (usando ;come separatore). Uscita: 1se coniugato, in 0caso contrario.

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

Nessun teorema sulle permutazioni usate (per pura ignoranza); solo forza bruta e questi due fatti:

  • Per due permutazioni p e q , la composizione pq è equivalente all'uso di p per indicizzare gli elementi di q .

  • La condizione x = gyg −1 è equivalente a xg = gy .

Codice commentato:

x      % Implicitly input first permutation, x. Delete it. Gets copied into clipboard G
Y@     % Implicitly input second permutation, y. Push a matrix with all permutations
       % of its elements, each permutation on a different row. So each matrix row is
       % a permutation of [1 2 ...n], where n is the size of y
!      % Transpose. Now each permutation is a column
"      % For each column
  &G   %   Push x, then y
  @    %   Push current column. This is a candidate g permutation
  )    %   Reference indexing. This gives g composed with y
  @    %   Push current column again
  b    %   Bubble up. Moves x to the top of the stack
  )    %   Reference indexing. This gives x composed with g
  X=   %   Are they equal as vectors? Gives true or false
  v    %   Concatenate stack so far. The stack contains the latest true/false result
       %   and possibly the accumulated result from previous iterations
  a    %   Any: gives true if any element is true. This is the "accumulating" function
       % Implicit end. Implicit display
— Luis Mendo
fonte
2

Gelatina , 11 byte

Œ!©Ụ€ịị"®⁸e

Provalo online!

Come funziona

Œ!©Ụ€ịị"®⁸e  Main link. Left argument: x. Right argument: y

Œ!©          Take all permutations g of x. Copy the result to the register.
   Ụ€        Grade up each; sort the indices of each permutation g by their
             corresponding values. For permutations of [1, ..., n], grading up
             essentially computes the inverse, g⁻¹.
     ị       Let each g⁻¹ index into y, computing g⁻¹y.
      ị"®    Let the results index into the corresponding g, computing g⁻¹yg.
         ⁸e  Test if x occurs in the result.
— Dennis
fonte
Per quanto ho capito, è in realtà yche si indicizza in ciascuno g⁻¹, non viceversa. Vedi l'esempio (4 1 2 3)(2 1 3 4) = (4 2 1 3),. Con il tuo approccio, si tradurrebbe (1 4 2 3)invece, poiché il secondo si indicizza nel primo. Tenendo conto di ciò, ho una soluzione a 12 byte che non rovinerò ancora. :-)
— Erik the Outgolfer,
@EriktheOutgolfer Fixed.
— Dennis,
@Dennis Ma non sono giunto a questa conclusione sulla base della spiegazione, sono arrivato allo stesso identico approccio, tranne per il fatto che avevo qualcosa di simile Œ!©Ụ€⁹ịЀ®ị"⁸e(praticamente tutto indicizzato con argomenti invertiti), tranne che più breve dopo aver apportato importanti modifiche. Non penso g⁻¹ygsia lo stesso gyg⁻¹. Inoltre, penso che anche la tua risposta possa beneficiare di tali modifiche, ma, come ho già detto, non voglio ancora rovinare il divertimento.
— Erik the Outgolfer,
Sì, è esattamente lo stesso. Se x = g⁻¹yg, quindi gxg⁻¹ = y, così xe ysono coniugati.
— Dennis,
Hm, mi sento come se dovessi rivelare la mia soluzione a 12 byte quindi:eŒ!ị"Ụị@¥€¥¥
— Erik the Outgolfer,
1

Buccia , 9 byte

¤¦ṠmöLU¡!

Restituisce 1per coniugato e 0per non coniugato. Provalo online!

Spiegazione

La classe di coniugio di una permutazione P di L = [1,2, .., n] è determinata dalla multinsieme contenente il periodo minimo di ogni numero L sotto P . Quando P viene preso in formato elenco, posso sostituire L con P e ottenere lo stesso multiset. Il programma calcola il multiset corrispondente per ciascun input e verifica se uno è un sub-multiset dell'altro. Poiché hanno lo stesso numero di elementi, questo equivale a essere lo stesso multiset.

¤¦ṠmöLU¡!  Implicit inputs: two lists of integers.
¤          Apply one function to both and combine with another function.
  ṠmöLU¡!  First function. Argument: a list P.
  Ṡm       Map this function over P:
       ¡!  iterate indexing into P,
      U    take longest prefix with unique elements,
    öL     take its length.
 ¦         Combining function: is the first list a subset of the other, counting multiplicities?
— Zgarb
fonte
1

Perl, 61 58 57 byte

include +2 perap

Dare permutazioni basate su 0 come 2 linee su STDIN

perl -ap '$_=[@1]~~[@1=map{-grep$_-$G[$i++%@G],@F=@G[@F]}@G=@F,0]'
3 0 2 1
3 1 0 2
^D

L'algoritmo è una variazione minore rispetto a quello in soluzione di xnor

Questa versione precedente del codice colpisce un bug perl e scarica core per diversi input sul mio ultimo perl 5.26.1, ma funziona su un perl più vecchio 5.16.3.

@{$.}=map{-grep$_==$F[$i++%@F],@G=@F[@G]}@G=@F,0}{$_=@1~~@2

Probabilmente è l'ennesimo esempio del mio vecchio nemico perlgolf, il fatto che perl non rispetti correttamente il suo stack.

— Ton Hospel
fonte
1

JavaScript (ES6), 66 64 byte

(a,b,g=a=>b+a.map(h=(e,i)=>e-i&&1+h(a[e],i)).sort())=>g(a)==g(b)

Se ho letto correttamente le altre risposte, il problema equivale a contare i periodi di tutti gli elementi e verificare che i due elenchi abbiano lo stesso numero di ciascun periodo. Modifica: salvato 1 byte grazie a @Arnauld calcolando uno in meno rispetto al periodo. Ho salvato un altro byte grazie a @Arnauld abusando delle strane regole di coercizione di JavaScript per confrontare le matrici. Un altro byte potrebbe essere salvato dal curry ma non mi piace il curry a meno che non sia il pollo tikka masala.

— Neil
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.