Giới thiệu

Chúng ta hãy định nghĩa một hàm ternary là một hàm từ bộ ba phần tử thành S = {0,1,2}chính nó: nó liên kết với từng phần tử của Sphần tử khác S. Một ví dụ về chức năng ternary flà

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

Có chính xác 27 hàm ternary khác nhau và chúng tôi biểu diễn chúng với các số nguyên từ 0 đến 26: một hàm fđược mã hóa thành f(0) + 3*f(1) + 9*f(2). Hàm ví dụ trên được mã hóa là số 6.

Chúng ta có thể áp dụng hai hàm ternary fvà gtheo thứ tự, và nếu f(g(k)) == g(f(k))giữ cho tất cả ktrong S, thì các hàm sẽ đi lại . Nhiệm vụ của bạn là xác minh xem đây có phải là trường hợp không.

Đầu vào

Đầu vào của bạn là hai số nguyên trong phạm vi bao gồm từ 0 đến 26. Chúng đại diện cho hai hàm ternary fvà g. Đầu vào phải được thực hiện ở định dạng thập phân, nhị phân hoặc đơn nguyên (chuỗi 1s).

Đầu ra

Đầu ra của bạn là một giá trị trung thực nếu fvà gđi lại, và giá trị chim ưng nếu chúng không. Bạn có thể không cho rằng các đầu vào được đặt hàng.

Ví dụ

Hãy xem xét các đầu vào 5 và 16. Chúng mã hóa các hàm ternary

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

Chúng tôi có f(g(1)) == f(2) == 0và g(f(1)) == g(1) == 2, vì vậy fvà gkhông đi làm và đầu ra chính xác là falsey.

Mặt khác, đầu vào 3 và 10 mã hóa các chức năng ternary

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

và nó có thể được xác nhận f(g(k)) == g(f(k))giữ cho tất cả ktrong S. Sau đó, đầu ra chính xác là trung thực.

Dưới đây là bảng 27 × 27 của tất cả các đầu vào có thể, với việc +đánh dấu đầu ra trung thực và -đầu ra falsey:

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

Quy tắc và tính điểm

Bạn có thể viết một chương trình đầy đủ hoặc một chức năng. Số byte thấp nhất sẽ thắng và các sơ hở tiêu chuẩn không được phép.

Thạch, 17 14 13 byte

+13ḃ3Um0ị2/⁼/

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp 27 × 27 .

Làm thế nào nó hoạt động

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

Truthy là một mảng với tất cả những người. Falsy là một mảng chứa ít nhất một số không.

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp (mất vài giây).

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

Đưa ra một đầu vào i, chúng ta có thể thực hiện chức năng được biểu thị bằng ncách thực hiện n/3**i%3để trích xuất ichữ số thứ ba của n. Hàm kiểm tra rằng cùng một kết quả nhận được cho mỗi 0,1,2khi áp dụng các hàm theo một trong hai thứ tự. Trên thực tế, vì bước đầu tiên đang thực hiện 3**, [1,3,9]thay vào đó , thử nghiệm này .

Việc sử dụng lại mã có vẻ lãng phí, nhưng tôi không thấy cách nào tốt hơn. Đối chiếu:

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)

Thật không may, chuyển đổi cơ sở 3 quá đắt:

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

Toán học, 77 byte

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

Toán học lập chỉ mục một lần nữa của Mathematica!