Introducción

Definamos una función ternaria como una función del conjunto de tres elementos S = {0,1,2}en sí misma: se asocia a cada elemento de Sotro elemento de S. Un ejemplo de una función ternaria fes

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

Hay exactamente 27 funciones ternarias diferentes, y las representamos con números enteros del 0 al 26: una función fse codifica como f(0) + 3*f(1) + 9*f(2). La función de ejemplo anterior está codificada como el número 6.

Podemos aplicar dos funciones ternarias fy gen secuencia, y si se f(g(k)) == g(f(k))mantiene para todo kadentro S, entonces las funciones conmutan . Su tarea es verificar si este es el caso.

Entrada

Sus entradas son dos enteros en el rango inclusivo de 0 a 26. Representan dos funciones ternarias fy g. La entrada debe tomarse en 1formato decimal, binario o unario (cadena de s).

Salida

Su salida es un valor verdadero si fyg conmuta, y un valor falso si no lo hacen. No puede suponer que las entradas están ordenadas.

Ejemplos

Considere las entradas 5 y 16. Codifican las funciones ternarias

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

Tenemos f(g(1)) == f(2) == 0y g(f(1)) == g(1) == 2, así, fy gno conmutamos y la salida correcta es falsey.

Por otro lado, las entradas 3 y 10 codifican las funciones ternarias.

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

y se puede verificar que f(g(k)) == g(f(k))se cumple para todos ken S. Entonces el resultado correcto es verdadero.

Aquí está la tabla 27 × 27 de todas las entradas posibles, con +una salida verdadera y -una salida falsey:

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

Reglas y puntaje

Puede escribir un programa completo o una función. El conteo de bytes más bajo gana, y las lagunas estándar no se permiten.

Jalea, 17 14 13 bytes

+13ḃ3Um0ị2/⁼/

Pruébalo en línea! o verificar todos los casos 27 × 27 .

Cómo funciona

+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 bytes

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

La verdad es una matriz con todos los unos. Falsy es una matriz que contiene al menos un cero.

Pruébalo en línea! o verificar todos los casos (toma unos segundos).

       % 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 bytes

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

Dada una entrada i, podemos implementar la función representada por nhaciendo n/3**i%3para extraer el iésima ternaria de n. La función verifica que se obtenga el mismo resultado para cada una de ellas 0,1,2al aplicar las funciones en cualquier orden. En realidad, dado que el primer paso es hacerlo 3**, esto prueba con en su [1,3,9]lugar.

La reutilización del código parece un desperdicio, pero no vi una mejor manera. Comparar:

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 bytes

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

Lamentablemente, la conversión de base 3 era demasiado cara:

(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 bytes

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

¡La indexación basada en One de Mathematica ataca de nuevo!