บทนำ

ลองกำหนดฟังก์ชั่น ternaryเป็นฟังก์ชั่นจากชุดสามองค์ประกอบS = {0,1,2}กับตัวเองมันจะเชื่อมโยงไปยังองค์ประกอบของแต่ละองค์ประกอบของผู้อื่นS Sตัวอย่างหนึ่งของฟังก์ชั่นประกอบไปด้วยfคือ

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

มีฟังก์ชั่นตรง 27 ternary ที่แตกต่างกันและเราเป็นตัวแทนของพวกเขาด้วยจำนวนเต็ม 0-26: ฟังก์ชั่นจะถูกเข้ารหัสเป็นf f(0) + 3*f(1) + 9*f(2)ฟังก์ชั่นตัวอย่างข้างต้นถูกเข้ารหัสเป็นหมายเลข 6

เราสามารถใช้ฟังก์ชั่นสอง ternary fและgในลำดับและถ้าf(g(k)) == g(f(k))ถือหุ้นทั้งหมดkในSนั้นฟังก์ชั่นการเดินทาง งานของคุณคือการตรวจสอบว่าเป็นกรณีนี้หรือไม่

อินพุต

อินพุตของคุณเป็นจำนวนเต็มสองจำนวนในช่วงรวมจาก 0 ถึง 26 พวกเขาเป็นตัวแทนสองฟังก์ชันประกอบไปด้วยfและ gต้องป้อนข้อมูลในรูปแบบทศนิยมฐานสองหรือ1รูปแบบสตริง (สตริง)

เอาท์พุต

ผลลัพธ์ของคุณเป็นค่าความจริงหากfและการgเดินทางและค่าความผิดพลาดหากพวกเขาไม่ คุณอาจไม่คิดว่าอินพุตจะถูกเรียงลำดับ

ตัวอย่าง

พิจารณาอินพุต 5 และ 16 ซึ่งเข้ารหัสฟังก์ชันที่ประกอบไปด้วย

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

เรามีf(g(1)) == f(2) == 0และg(f(1)) == g(1) == 2ดังนั้นfและgไม่เดินทางและผลลัพธ์ที่ถูกต้องเป็นเท็จ

ในขณะที่อินพุต 3 และ 10 เข้ารหัสฟังก์ชั่นประกอบไปด้วย

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

และสามารถตรวจสอบได้ว่าf(g(k)) == g(f(k))ถือหุ้นทั้งหมดในk Sจากนั้นผลลัพธ์ที่ถูกต้องคือความจริง

นี่คือตาราง 27 × 27 ของอินพุตที่เป็นไปได้ทั้งหมดพร้อมการ+ทำเครื่องหมายเอาต์พุตที่-เป็นความจริงและเอาต์พุตที่ผิดพลาด:

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

กฎและการให้คะแนน

คุณสามารถเขียนโปรแกรมเต็มรูปแบบหรือฟังก์ชั่น จำนวนไบต์ต่ำสุดที่ชนะและช่องโหว่มาตรฐานไม่ได้รับอนุญาต

เยลลี่, 17 14 13 ไบต์

+13ḃ3Um0ị2/⁼/

ลองออนไลน์! หรือตรวจสอบทั้งหมด 27 × 27 ราย

มันทำงานอย่างไร

+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 ไบต์

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

ความจริงคืออาร์เรย์ที่มีทุกสิ่ง Falsy เป็นอาร์เรย์ที่มีศูนย์อย่างน้อยหนึ่งรายการ

ลองออนไลน์! หรือตรวจสอบทุกกรณี (ใช้เวลาสองสามวินาที)

       % 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 ไบต์

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

ได้รับการป้อนข้อมูลiเราสามารถใช้ฟังก์ชั่นที่แสดงโดยnโดยการทำn/3**i%3เพื่อแยกiTH ternary nหลัก ฟังก์ชั่นการตรวจสอบว่าผลลัพธ์เดียวกันจะได้รับสำหรับแต่ละ0,1,2เมื่อใช้ฟังก์ชั่นในลำดับใด ที่จริงแล้วตั้งแต่ขั้นตอนแรกกำลังทำการ3**ทดสอบนี้ด้วย[1,3,9]แทน

การนำโค้ดกลับมาใช้ใหม่ดูสิ้นเปลือง แต่ฉันไม่เห็นวิธีที่ดีกว่านี้ เปรียบเทียบ:

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 ไบต์

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

น่าเสียดายที่การแปลงฐาน 3 มีราคาแพงเกินไป:

(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 ไบต์

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

การจัดทำดัชนีแบบฐานเดียวของ Mathematica จะนัดหยุดอีก