27 कार्यों की गणना

Question

परिचय

आइए तीन-तत्व से स्वयं के लिए एक फ़ंक्शन के रूप में एक टर्नरी फ़ंक्शन को परिभाषित करें S = {0,1,2}: यह Sदूसरे तत्व के प्रत्येक तत्व को जोड़ता है S। एक टर्नरी फ़ंक्शन fका एक उदाहरण है

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

27 अलग-अलग टर्नरी फ़ंक्शन हैं, और हम उन्हें 0 से 26 तक पूर्णांक के साथ दर्शाते हैं: एक फ़ंक्शन के fरूप में एन्कोड किया गया है f(0) + 3*f(1) + 9*f(2)। उपरोक्त उदाहरण फ़ंक्शन संख्या 6 के रूप में एन्कोडेड है।

हम दो टर्नरी कार्यों fऔर gअनुक्रम को लागू कर सकते हैं , और यदि f(g(k)) == g(f(k))सभी kमें पकड़ है S, तो फ़ंक्शन कम्यूट करते हैं । आपका कार्य यह सत्यापित करना है कि क्या यह मामला है।

इनपुट

आपके इनपुट 0 से 26 तक समावेशी सीमा में दो पूर्णांक हैं। वे दो टर्नरी कार्यों का प्रतिनिधित्व करते हैं fऔर g। इनपुट को दशमलव, बाइनरी या अनरी (स्ट्रिंग ऑफ़ 1एस) प्रारूप में लिया जाना चाहिए ।

उत्पादन

आपका आउटपुट एक है truthy मूल्य अगर fऔर gलघुकरण, और एक falsey मूल्य अगर वे ऐसा नहीं करते। आप यह नहीं मान सकते हैं कि इनपुट का आदेश दिया गया है।

उदाहरण

इनपुट्स 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। फिर सही आउटपुट सत्य है।

यहाँ एक संभावित +आउटपुट और -एक गलत आउटपुट के निशान के साथ, सभी संभव इनपुट की २ mark × २ is तालिका है :

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

नियम और स्कोरिंग

आप एक पूर्ण कार्यक्रम या एक फ़ंक्शन लिख सकते हैं। सबसे कम बाइट गिनती जीतता है, और मानक खामियों को रोक दिया जाता है।

Comments

क्या इनपुट दो संख्याओं वाला एक सरणी हो सकता है?

— लुइस मेन्डो

@DonMuesli मेटा पर सहमति के अनुसार अनुमति दी गई है ।

— ज़र्गब

Answer 1

जेली, 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.

Comments

मैंने सभी परीक्षण मामलों को सत्यापित करने और मैट्रिक्स को प्रदर्शित करने के आपके विचार की नकल की है :-)

— लुइस मेंडो

Answer 2

MATL , 19 18 बाइट्स

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

सत्य सभी के साथ एक सरणी है। मिथ्या एक सरणी है जिसमें कम से कम एक शून्य होता है।

इसे ऑनलाइन आज़माएं! या सभी मामलों को सत्यापित करें (कुछ सेकंड लगते हैं)।

       % 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

Comments

मुझे लगता है कि आमतौर पर केवल खाली सूची को गलत माना जाता है।

— टिमटेक

@Timtech जो भाषा पर निर्भर करता है। MATL में, एरे जिसमें शून्य होते हैं, मिथ्या हैं।

— डेनिस

ठीक है, बस जाँच कर रहा हूँ ...

— टाइमटेक

@ टिमटेक ज़रूर! यहां यह अधिक विस्तार से है: एक अभिव्यक्ति सच है जब इसका परिणाम गैर-रिक्त होता है और इसमें केवल गैर-तत्व (तार्किक या वास्तविक संख्यात्मक) होते हैं

— लुइस मेंडो

Answer 3

पायथन 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निकालने के लिए iकी वें त्रिगुट अंकों 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])

Answer 4

जावास्क्रिप्ट (ईएस 7), 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))

Answer 5

गणितज्ञ, 77 बाइट्स

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

गणितज्ञ का एक-आधारित अनुक्रमण फिर से शुरू होता है!

Comments

{1,1,1}एक चर को असाइन करने के लिए छोटा और उस का उपयोग करें।

— कैलक्यूलेटरफलाइन