introduction

Définissons une fonction ternaire comme une fonction de l'ensemble de trois éléments S = {0,1,2}à elle-même: elle s'associe à chaque élément d' Sun autre élément de S. Un exemple de fonction ternaire fest

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

Il existe exactement 27 fonctions ternaires différentes, et nous les représentons avec des entiers de 0 à 26: une fonction fest codée comme f(0) + 3*f(1) + 9*f(2). L'exemple de fonction ci-dessus est codé comme le numéro 6.

Nous pouvons appliquer deux fonctions ternaires fet gdans l' ordre, et si f(g(k)) == g(f(k))valable pour tous kdans S, les fonctions commuer . Votre tâche consiste à vérifier si tel est le cas.

Contribution

Vos entrées sont deux entiers compris entre 0 et 26. Ils représentent deux fonctions ternaires fet g. L'entrée doit être prise au 1format décimal, binaire ou unaire (chaîne de s).

Sortie

Votre sortie est une valeur véridique si fet faites lag navette, et une valeur falsey si ce n'est pas le cas. Vous ne pouvez pas supposer que les entrées sont ordonnées.

Exemples

Considérez les entrées 5 et 16. Elles codent les fonctions ternaires

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

Nous avons f(g(1)) == f(2) == 0et g(f(1)) == g(1) == 2, donc fet gne pas faire la navette et la sortie correcte est falsey.

En revanche, les entrées 3 et 10 codent les fonctions ternaires

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

et il peut être vérifié que f(g(k)) == g(f(k))détient pour tous kdans S. Ensuite, la sortie correcte est véridique.

Voici le tableau 27 × 27 de toutes les entrées possibles, avec +marquage d'une sortie véridique et d' -une sortie falsey:

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

Règles et notation

Vous pouvez écrire un programme complet ou une fonction. Le nombre d'octets le plus bas l'emporte et les failles standard sont interdites.

Gelée, 17 14 13 octets

+13ḃ3Um0ị2/⁼/

Essayez-le en ligne! ou vérifiez tous les 27 × 27 cas .

Comment ça marche

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

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

Truthy est un tableau avec tous ceux. Falsy est un tableau contenant au moins un zéro.

Essayez-le en ligne! ou vérifiez tous les cas (prend quelques secondes).

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

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

Étant donné une entrée i, nous pouvons implémenter la fonction représentée par nen faisant n/3**i%3pour extraire le iième chiffre ternaire de n. La fonction vérifie que le même résultat est obtenu pour chacun 0,1,2lors de l'application des fonctions dans l'un ou l'autre ordre. En fait, puisque la première étape est en cours 3**, cela teste avec à la [1,3,9]place.

La réutilisation du code semble gaspilleuse, mais je n'ai pas vu de meilleure façon. Comparer:

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 octets

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

Malheureusement, la conversion en base 3 était trop chère:

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

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

L'indexation One-based de Mathematica frappe à nouveau!