Einführung

Definieren wir eine ternäre Funktion als eine Funktion aus der Dreielementmenge S = {0,1,2}zu sich selbst: Sie wird jedem Element eines Sanderen Elements von zugeordnet S. Ein Beispiel für eine ternäre Funktion fist

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

Es gibt genau 27 verschiedene ternäre Funktionen, und wir stellen sie mit ganzen Zahlen von 0 bis 26 dar: Eine Funktion fwird als codiert f(0) + 3*f(1) + 9*f(2). Die obige Beispielfunktion ist als Nummer 6 codiert.

Wir können zwei ternären Funktionen anwenden fund gin der Folge, und wenn f(g(k)) == g(f(k))für alle hält kin S, dann die Funktionen pendeln . Ihre Aufgabe ist es zu überprüfen, ob dies der Fall ist.

Eingang

Ihre Eingaben sind zwei ganze Zahlen im Bereich von 0 bis 26. Sie repräsentieren zwei ternäre Funktionen fund g. Die Eingabe muss im Dezimal-, Binär- oder Unärformat (Zeichenfolge von 1s) erfolgen.

Ausgabe

Ihre Ausgabe ist ein wahrer Wert, wenn fund gpendeln, und ein falscher Wert, wenn sie nicht. Sie können nicht davon ausgehen, dass die Eingänge geordnet sind.

Beispiele

Betrachten Sie die Eingänge 5 und 16. Sie codieren die ternären Funktionen

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

Wir haben f(g(1)) == f(2) == 0und g(f(1)) == g(1) == 2, so fund gnicht pendeln und die korrekte Ausgabe ist Falsey.

Andererseits codieren die Eingänge 3 und 10 die ternären Funktionen

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

und es kann überprüft werden , dass f(g(k)) == g(f(k))für alle hält kin S. Dann ist die richtige Ausgabe wahr.

Hier ist die 27 × 27-Tabelle aller möglichen Eingaben, wobei +eine wahrheitsgemäße Ausgabe und -eine falsche Ausgabe markiert sind:

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

Regeln und Wertung

Sie können ein vollständiges Programm oder eine Funktion schreiben. Die niedrigste Byteanzahl gewinnt, und Standardlücken sind nicht zulässig.

Jelly, 17 14 13 Bytes

+13ḃ3Um0ị2/⁼/

Probieren Sie es online! oder überprüfen Sie alle 27 × 27 Fälle .

Wie es funktioniert

+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)=

Wahrheit ist ein Array mit allen. Falsy ist ein Array, das mindestens eine Null enthält.

Probieren Sie es online! oder überprüfen Sie alle Fälle (dauert einige Sekunden).

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

Bei einer gegebenen Eingabe ikönnen wir die durch dargestellte Funktion implementieren, nindem wir n/3**i%3die idritte Ziffer von extrahieren n. Die Funktion prüft, ob bei jeder 0,1,2Anwendung der Funktionen in beliebiger Reihenfolge dasselbe Ergebnis erzielt wird. Da der erste Schritt darin besteht 3**, wird [1,3,9]stattdessen mit getestet .

Die Wiederverwendung von Code sieht verschwenderisch aus, aber ich habe keinen besseren Weg gefunden. Vergleichen Sie:

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)

Leider war die Konvertierung der Basis 3 zu teuer:

(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]&

Die einseitige Indexierung von Mathematica schlägt wieder zu!