introduzione

Definiamo una funzione ternaria come una funzione dal set S = {0,1,2}di tre elementi a se stesso: si associa a ciascun elemento di Sun altro elemento di S. Un esempio di una funzione ternaria fè

f(0) = 0; f(1) = 2; f(2) = 0

Esistono esattamente 27 diverse funzioni ternarie e le rappresentiamo con numeri interi da 0 a 26: una funzione fè codificata come f(0) + 3*f(1) + 9*f(2). La funzione di esempio sopra è codificata come il numero 6.

Possiamo applicare due funzioni ternarie fe gin sequenza, e se f(g(k)) == g(f(k))vale per all kin S, allora le funzioni commutano . Il tuo compito è verificare se questo è il caso.

Ingresso

I tuoi input sono due numeri interi compresi tra 0 e 26. Rappresentano due funzioni ternarie fe g. L'input deve essere preso in formato decimale, binario o unario (stringa di 1s).

Produzione

Il tuo output è un valore vero se fe gpermuta, e un valore falso se non lo fanno. Non si può presumere che gli ingressi siano ordinati.

Esempi

Considera gli ingressi 5 e 16. Codificano le funzioni ternarie

f(0) = 2; f(1) = 1; f(2) = 0
g(0) = 1; g(1) = 2; g(2) = 1

Abbiamo f(g(1)) == f(2) == 0e g(f(1)) == g(1) == 2, quindi fe gnon commutano e l'uscita corretta è Falsey.

D'altra parte, gli ingressi 3 e 10 codificano le funzioni ternarie

f(0) = 0; f(1) = 1; f(2) = 0
g(0) = 1; g(1) = 0; g(2) = 1

e può essere verificato che f(g(k)) == g(f(k))vale per tutti kin S. Quindi l'output corretto è veritiero.

Ecco la tabella 27 × 27 di tutti gli input possibili, con +un output true e -un output false:

+ - - + - - + - - + - - + - - + - - + - - + - - + - -
- + - - - - - - - - - - + - - - - - - - - + - - - - -
- - + - - - - - - - - - - - - - - - - - - + - - + - -
+ - - + - - - - - - + - - + - - - - + - - + - - - - -
- - - - + - - - - - - - - + - - - - - - - + - - - - -
- - - - - + - - - - - - - + - - - - - - - + - - - - -
+ - - - - - + - - - - - - - - - - - - - - + - - - - -
- - - - - - - + - - - + - - - - - - - - - + - - - - -
- - - - - - - - + - - - - - - - - - + - - + - - - - -
+ - - - - - - - - + - - - - - - - - - - - + - - - - -
- - - + - - - - - - + - - - - - - - - - - + - - - - -
- - - - - - - + - - - + - - - - - - - - - + - - - - -
+ + - - - - - - - - - - + + - - - - - - - + + - - - -
- - - + + + - - - - - - + + + - - - - - - + + + - - -
- - - - - - - - - - - - - + + - - - - - - + - - - - -
+ - - - - - - - - - - - - - - + - - - - - + - - - - -
- - - - - - - - - - - - - - - - + - - - - + - + - - -
- - - - - - - - - - - - - - - - - + - - - + + - - - -
+ - - + - - - - + - - - - - - - - - + - - + - - - - +
- - - - - - - - - - - - - - - - - - - + - + - - - - +
- - - - - - - - - - - - - - - - - - - - + + - - - - +
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
- - - - - - - - - - - - + + - - - + - - - + + - - - +
- - - - - - - - - - - - - + - - + - - - - + - + + - +
+ - + - - - - - - - - - - - - - - - - - - + - + + - +
- - - - - - - - - - - - - - - - - - - - - + - - - + +
- - - - - - - - - - - - - - - - - - + + + + + + + + +

Regole e punteggio

È possibile scrivere un programma completo o una funzione. Vince il conteggio di byte più basso e non sono consentite scappatoie standard .

Gelatina, 17 14 13 byte

+13ḃ3Um0ị2/⁼/

Provalo online! o verifica tutti i 27 × 27 casi .

Come funziona

+13ḃ3Um0ị2/⁼/  Main link. Argument: [f, g] (encoded as integers)

+13            Add 13 ([1, 1, 1] in base 3) to f and g.
   ḃ3          Convert f + 13 and g + 13 to bijective base 3.
               Bijective base 3 uses the digits 1 to 3 instead of 0 to 2.
               This yields [[f(2)+1, f(1)+1, f(0)+1], [g(2)+1, g(1)+1, g(0)+1]].
               The increments account for 1-based indexing.
     U         Reverse each digit array.
               This yields [[f(0)+1, f(1)+1, f(2)+1], [g(0)+1, g(1)+1, g(2)+1]].
      m0       Concatenate the list with a reversed copy of itself.
        ị2/    Split the result into pairs, and reduce each one by indexing.
               This computes g○f and f○g.
          ⁼/   Reduce by match; return 1 iff g○f = f○g.

MATL , 19 18 byte

I:PII$YAZ{Y:)1Mw)=

Verità è un array con tutti. Falsy è un array contenente almeno uno zero.

Provalo online! oppure verifica tutti i casi (richiede alcuni secondi).

       % implicitly input an array of two numbers
I:P    % push [3 2 1]
I      % push 3
I$     % specify that the next function takes 3 inputs
YA     % convert input to base 3 with alphabet [3 2 1] and 3 digits. Gives 2x3 array
Z{     % convert into cell of two cells, one with each row
Y:     % split cell array. We have two arrays on the stack, one per function
)      % index operation to compute f ∘ g. Function composition is indexing
1M     % push the two arrays again
w      % swap the two arrays
)      % index operation to compute g ∘ f
=      % test for equality element-wise
       % implicitly display

Python 2, 61 byte

lambda m,n:all(n/3**(m/i%3)%3==m/3**(n/i%3)%3for i in[1,3,9])

Dato un input i, possiamo implementare la funzione rappresentata nfacendo n/3**i%3per estrarre la icifra ternaria di n. La funzione verifica che si ottenga lo stesso risultato per ciascuno di essi 0,1,2quando si applicano le funzioni in entrambi gli ordini. In realtà, dal momento che il primo passo sta facendo 3**, questo prova [1,3,9]invece.

Il riutilizzo del codice sembra dispendioso, ma non ho visto un modo migliore. Confrontare:

q=lambda x,i:x/3**i%3;lambda m,n:all(q(m,q(n,i))==q(n,q(m,i))for i in[0,1,2])

JavaScript (ES7), 68 byte

(a,b)=>![0,1,2].some(n=>t(a,t(b,n))-t(b,t(a,n)),t=(a,n)=>a/3**n%3|0)

Sfortunatamente la conversione in base 3 era troppo costosa:

(a,b)=>[0,1,2].every(n=>a[b[n]]==b[a[n]],g=a=>(27+a).toString(3).slice(1),a=g(a),b=g(b))

Mathematica, 77 byte

Reverse[#][[#2+{1,1,1}]]==Reverse[#2][[#+{1,1,1}]]&@@IntegerDigits[{##},3,3]&

L'indicizzazione One-based di Mathematica colpisce ancora!