संतुलित टर्नरी तर्क

Question

संतुलित टर्नरी तर्क

त्रिगुट सामान्य रूप से आधार 3, कहने के लिए है कि का दूसरा नाम है, प्रत्येक अंक है 0, 1या 2, और प्रत्येक जगह अगले जगह के रूप में ज्यादा के रूप में मूल्य 3 बार है।

संतुलित टर्नरी टर्नरी का एक संशोधन है जो अंकों के और -1, का उपयोग करता है । यह एक संकेत की जरूरत नहीं का लाभ है। प्रत्येक स्थान अभी भी अगले स्थान से 3 गुना अधिक मूल्य का है। पहले कुछ धनात्मक पूर्णांक इसलिए कर रहे हैं , , , , पहले कुछ नकारात्मक पूर्णांक हैं, जबकि , , , , ।01[1][1, -1][1, 0][1, 1][1, -1, -1][-1][-1, 1][-1, 0][-1, -1][-1, 1, 1]

आपके पास तीन इनपुट हैं x, y, z। zया तो है -1, 0या 1, जबकि, xऔर yसे हो सकता है -3812798742493करने के लिए 3812798742493समावेशी।

पहला चरण कन्वर्ट करने के लिए xऔर yदशमलव से संतुलित टर्नरी है। इससे आपको 27 ट्रिट (टेनीरी डाइजेस्ट) मिलनी चाहिए। इसके बाद आप से trits गठबंधन करने के लिए है xऔर yजोड़ों में एक त्रिगुट आपरेशन का उपयोग करते हुए और फिर दशमलव के परिणाम वापस परिवर्तित।

आप zइन तीन टेनेरी ऑपरेशनों में से किसी एक में मानचित्र के कौन से मान चुन सकते हैं :

• A: दो ट्रिट को देखते हुए, यदि या तो शून्य है, तो परिणाम शून्य है, अन्यथा परिणाम -1 है यदि वे अलग हैं या 1 यदि वे समान हैं।
• B: दो ट्रिट को देखते हुए, यदि या तो शून्य है, तो परिणाम अन्य ट्रिट है, अन्यथा परिणाम शून्य है अगर वे अलग हैं या यदि वे समान हैं तो नकार।
• C: दो ट्रिट को देखते हुए, परिणाम शून्य है यदि वे अलग हैं या उनका मूल्य यदि वे समान हैं।

उदाहरण। मान लीजिए xहै 29और yहै 15। संतुलित टर्नरी में, ये बन जाते हैं [1, 0, 1, -1]और [1, -1, -1, 0]। (शेष 23 शून्य ट्रिट को संक्षिप्तता के लिए छोड़ दिया गया है।) प्रत्येक संबंधित संचालन के बाद वे बन जाते हैं A: [1, 0, -1, 0], B: [-1, -1, 0, -1], C: [1, 0, 0, 0]। परिणामों को दशमलव में वापस बदल दिया जाता है 24, -37और 27क्रमशः। अधिक उदाहरणों के लिए निम्नलिखित संदर्भ कार्यान्वयन का प्रयास करें:

function reference(xd, yd, zd) {
    var rd = 0;
    var p3 = 1;
    for (var i = 0; i < 27; i++) {
        var x3 = 0;
        if (xd % 3 == 1) {
            x3 = 1;
            xd--;
        } else if (xd % 3) {
            x3 = -1;
            xd++;
        }
        var y3 = 0;
        if (yd % 3 == 1) {
            y3 = 1;
            yd--;
        } else if (yd % 3) {
            y3 = -1;
            yd++;
        }
        var r3 = 0;
        if (zd < 0) { // option A
            if (x3 && y3) r3 = x3 == y3 ? 1 : -1;
        } else if (zd > 0) { // option B
            if (!x3) r3 = y3;
            else if (!y3) r3 = x3;
            else r3 = x3 == y3 ? -x3 : 0;
        } else { // option C
            r3 = x3 == y3 ? x3 : 0;
        }
        rd += r3 * p3;
        p3 *= 3;
        xd /= 3;
        yd /= 3;
    }
    return rd;
}

<div onchange=r.textContent=reference(+x.value,+y.value,+z.selectedOptions[0].value)><input type=number id=x><input type=number id=y><select id=z><option value=-1>A</option><option value=1>B</option><option value=0>C</option><select><pre id=r>

संदर्भ कार्यान्वयन ऊपर दिए गए चरणों का अनुसरण करता है, लेकिन आप निश्चित रूप से उसी एल्गोरिदम का उपयोग करने के लिए स्वतंत्र हैं जो समान परिणाम उत्पन्न करता है।

यह कोड-गोल्फ है , इसलिए सबसे छोटा कार्यक्रम या फ़ंक्शन जो किसी भी मानक खामियों का उल्लंघन करता है जीतता है!

Comments

यदि संख्याओं के लिए मूल प्रारूप संतुलित टर्नरी है (बाइनरी के विपरीत), तो क्या हमें इसे सामान्य तरीके से इनपुट के रूप में लेने की अनुमति है (जिसके परिणामस्वरूप संतुलित टर्नरी में कोई रूपांतरण नहीं होता है)?

— wizzwizz4

संबंधित

— Giuseppe

करता है zमें से एक होना चाहिए -1,0,1या हम किसी भी तीन सुसंगत और अलग-अलग मान ले सकते हैं? मैंने 1,2,3अपने उत्तर में चयन किया है, और इसके बारे में कुछ भ्रम है।

— ग्यूसेप

@Giuseppe क्षमा करें, केवल संतुलित ternary अंक की अनुमति है।

— नील

मैंने कुछ उलट-पुलट पढ़ा ... बहुत शब्द और कोई सूत्र नहीं

— RosLuP

Answer 1

क्लीन , 231 ... 162 बाइट्स

import StdEnv
$n=tl(foldr(\p[t:s]#d=sign(2*t/3^p)
=[t-d*3^p,d:s])[n][0..26])
@x y z=sum[3^p*[(a+b)/2,[1,-1,0,1,-1]!!(a+b+2),a*b]!!(z+1)\\a<- $x&b<- $y&p<-[0..26]]

फ़ंक्शन को परिभाषित करता है @, तीन Intएस ले रहा है और ए दे रहा है Int।
ऑपरेटर्स मैप के रूप में 1 -> A, 0 -> B, -1 -> C।

इसे ऑनलाइन आज़माएं!

फ़ंक्शन $, अंक स्थानों पर एक लंबर को मोड़ देता है [0..26], टर्नरी अंकों की सूची में। यह अपेक्षित संख्या से वर्तमान कुल अंतर रखने के लिए पैदावार के प्रमुख का उपयोग करता है (यही कारण है कि इसे लौटने से पहले पूंछ किया जाता है), और sign(2*t/3^p)उपज के लिए वर्तमान अंक निर्धारित करने के लिए। साइन ट्रिक के बराबर है if(abs(2*t)<3^p)0(sign t)।

Comments

मुझे क्लीन नहीं पता है, लेकिन मुझे लगता है कि आपने संतुलित टर्नरी में कैसे परिवर्तित किया है, $nमुझे लगता है कि (मुझे लगता है)। क्या आप इसके लिए स्पष्टीकरण जोड़ सकते हैं?

— Giuseppe

@Giuseppe बिल्कुल, मैं आज समय मिलने पर एक स्पष्टीकरण जोड़ूंगा।

— Οurous

@Giuseppe क्या आपके सवाल का जवाब देता है?

— Ο .सुर

हाँ! यह समझ आता है। अत्यंत चालाक!

— Giuseppe

Answer 2

जेली , 39 बाइट्स

×=
×
+ị1,-,0
A-r1¤ṗœs2ṚẎị@ȯµ€Uz0ZU⁹ŀ/ḅ3

एक पूरा कार्यक्रम दो तर्क, ले रही है [x,y], और z
... जहां zहै {A:-1, B:0, C:1}
जो परिणाम प्रिंट

इसे ऑनलाइन आज़माएं! नोट: गोल्फ की विधि इसे धीमा कर देती है - यह परिवर्तित संस्करण तेज है (प्रत्येक कार्टेशियन उत्पाद से पहले 3, छत और वेतन वृद्धि से लॉग)

कैसे?

×=       - Link  1 (1), B: list of trits L, list of trits R
×        - L multiplied by... (vectorises):
 =       -   L equal R? (vectorises)

×        - Link -1 (2), A: list of trits L, list of trits R
×        - L multiplied by R (vectorises)

+ị1,-,0  - Link  0 (3), C: list of trits L, list of trits R
+        - L plus R (vectorises)
  1,-,0  - list of integers = [1,-1,0]
 ị       - index into (vectorises) - 1-based & modular, so index -2 is equivalent to
         -                           index 1 which holds the value 1.

A-r1¤ṗœs2ṚẎị@ȯµ€Uz0ZU⁹ŀ/ḅ3 - Main link: list of integers [X,Y], integer Z
              µ€           - for each V in [X,Y]:
A                          -   absolute value = abs(V)
    ¤                      -   nilad followed by link(s) as a nilad:
 -                         -     literal minus one
   1                       -     literal one
  r                        -     inclusive range = [-1,0,1]
     ṗ                     -   Cartesian power, e.g. if abs(V)=3: [[-1,-1,-1],[-1,-1,0],[-1,-1,1],[-1,0,-1],[-1,0,0],[-1,0,1],[-1,1,-1],[-1,1,0],[-1,1,1],[0,-1,-1],[0,-1,0],[0,-1,1],[0,0,-1],[0,0,0],[0,0,1],[0,1,-1],[0,1,0],[0,1,1],[1,-1,-1],[1,-1,0],[1,-1,1],[1,0,-1],[1,0,0],[1,0,1],[1,1,-1],[1,1,0],[1,1,1]]
                           -                   (corresponding to: [-13       ,-12      ,-11      ,-10      ,-9      ,-8      ,-7       ,-6      ,-5      ,-4       ,-3      ,-2      ,-1      ,0      ,1      ,2       ,3      ,4      ,5        ,6       ,7       ,8       ,9      ,10      ,11     ,12     ,13     ] )
        2                  -   literal two
      œs                   -   split into equal chunks           [[[-1,-1,-1],[-1,-1,0],[-1,-1,1],[-1,0,-1],[-1,0,0],[-1,0,1],[-1,1,-1],[-1,1,0],[-1,1,1],[0,-1,-1],[0,-1,0],[0,-1,1],[0,0,-1],[0,0,0]],[[0,0,1],[0,1,-1],[0,1,0],[0,1,1],[1,-1,-1],[1,-1,0],[1,-1,1],[1,0,-1],[1,0,0],[1,0,1],[1,1,-1],[1,1,0],[1,1,1]]]
         Ṛ                 -   reverse                           [[[0,0,1],[0,1,-1],[0,1,0],[0,1,1],[1,-1,-1],[1,-1,0],[1,-1,1],[1,0,-1],[1,0,0],[1,0,1],[1,1,-1],[1,1,0],[1,1,1]],[[-1,-1,-1],[-1,-1,0],[-1,-1,1],[-1,0,-1],[-1,0,0],[-1,0,1],[-1,1,-1],[-1,1,0],[-1,1,1],[0,-1,-1],[0,-1,0],[0,-1,1],[0,0,-1],[0,0,0]]]
          Ẏ                -   tighten                            [[0,0,1],[0,1,-1],[0,1,0],[0,1,1],[1,-1,-1],[1,-1,0],[1,-1,1],[1,0,-1],[1,0,0],[1,0,1],[1,1,-1],[1,1,0],[1,1,1],[-1,-1,-1],[-1,-1,0],[-1,-1,1],[-1,0,-1],[-1,0,0],[-1,0,1],[-1,1,-1],[-1,1,0],[-1,1,1],[0,-1,-1],[0,-1,0],[0,-1,1],[0,0,-1],[0,0,0]]
                           -                   (corresponding to: [1      ,2       ,3      ,4      ,5        ,6       ,7       ,8       ,9      ,10     ,11      ,12     ,13     ,-13       ,-12      ,-11      ,-10      ,-9      ,-8      ,-7       ,-6      ,-5      ,-4       ,-3      ,-2      ,-1      ,0      ] )
           ị@              -   get item at index V (1-based & modular)
             ȯ             -   logical OR with V (just handle V=0 which has an empty list)
                U          - upend (big-endian -> little-endian for each)
                  0        - literal zero           }
                 z         - transpose with filler  } - pad with MSB zeros
                   Z       - transpose              }
                    U      - upend (little-endian -> big-endian for each)
                       /   - reduce with:
                      ŀ    -   link number: (as a dyad)
                     ⁹     -     chain's right argument, Z
                         3 - literal three
                        ḅ  - convert from base

Comments

मैं अपने जीवन के लिए गोल्फ भाषा नहीं पढ़ सकता, इसलिए जब आप कहते हैं कि 'धीमी', समय की जटिलता कितनी खराब है?

— Οurous

N की संतुलित त्रिगुट प्राप्त करने के लिए यह सभी (3 ^ n) लंबाई एब्स (N) ट्रिट्स की सूची (0, -1, और 1) बनाता है। तो हे (3 ^ अधिकतम (एब्स (एक्स), एब्स (वाई)))

— जोनाथन एलन

धन्यवाद, और स्पष्टीकरण के लिए मैं तुम्हें भी जोड़ा!

— Οसूर

एक ही विधि का उपयोग करके एक गतिमान संस्करण भी जोड़ा गया :)

— जोनाथन एलन

Answer 3

आर , 190 172 151 बाइट्स

function(a,b,z){M=t(t(expand.grid(rep(list(-1:1),27))))
P=3^(26:0)
x=M[M%*%P==a,]
y=M[M%*%P==b,]
k=sign(x+y)
switch(z+2,x*y,k*(-1)^(x+y+1),k*!x-y)%*%P}

इसे ऑनलाइन आज़माएं!

ट्रिट के सभी संयोजनों की गणना करता है और सही का चयन करता है। यह वास्तव में एक मेमोरी त्रुटि को फेंक देगा 27, क्योंकि 3^27यह एक बड़ी संख्या है, लेकिन यह सिद्धांत रूप में काम करेगा। TIO लिंक में केवल 11ट्रिट पूर्णांक समर्थन है; मुझे यकीन नहीं है कि यह किस समय या मेमोरी त्रुटियों के पहले बिंदु पर है, और मैं नहीं चाहता कि डेनिस मेरे लिए TIO को गाली दे!

पुराना उत्तर, 170 बाइट्स

यह सभी इनपुट्स के लिए काम करना चाहिए, हालांकि केवल 32-बिट पूर्णांक के साथ, वहाँ अपव्यय की संभावना है क्योंकि आर स्वचालित रूप से उन्हें बदल देगा double।

function(a,b,z){x=y={}
for(i in 0:26){x=c((D=c(0,1,-1))[a%%3+1],x)
y=c(D[b%%3+1],y)
a=(a+1)%/%3
b=(b+1)%/%3}
k=sign(x+y)
switch(z+2,x*y,k*(-1)^(x+y+1),k*!x-y)%*%3^(26:0)}

इसे ऑनलाइन आज़माएं!

ले जाता है -1के लिए A, 0के लिए B, और 1के लिए C।

इस उत्तर के लिए दृष्टिकोण को संतुलित टर्नरी में परिवर्तित करने के लिए पोर्ट करता है , हालांकि जब से हमें 27 से अधिक संतुलित ट्रिट्स की गारंटी नहीं है, यह उसके लिए अनुकूलित है।

आर , 160 बाइट्स

function(a,b,z){s=sample
x=y=rep(0,27)
P=3^(26:0)
while(x%*%P!=a&y%*%P!=b){x=s(-1:1,27,T)
y=s(-1:1,27,T)}
k=sign(x+y)
switch(z+2,x*y,k*(-1)^(x+y+1),k*!x-y)%*%P}

इसे ऑनलाइन आज़माएं!

यह संस्करण बेहद धीरे-धीरे समाप्त हो जाएगा। आधार रूपांतरण के bogosort, इस समारोह बेतरतीब ढंग से यह जब तक trits उठाता है किसी भी तरह जादुई ( 3^-54यह होने वाली का मौका) के लिए सही trits पाता है aऔर b, और फिर आवश्यक आपरेशन करता है। यह मूल रूप से कभी खत्म नहीं होगा।

Comments

मुझे लगता zहै कि यह प्रतिबंधित है {-1, 0, 1}।

— आउटगोल्फ

@EriktheOutgolfer आप zइन तीन

— डेनिस

@ डेनिस zया तो है -1, 0या1 , और मुझे लगता है कि उन "मूल्यों z" को संदर्भित किया जा रहा है।

— आउटगॉल्फ

यह एक दो-बाइट अंतर है, की जगह है switch(z,...)के साथ switch(z+2,...)तो यह एक छोटी सी परिवर्तन परवाह किए बिना किया जाएगा।

— ग्यूसेप

Answer 4

जेली , 47 बाइट्स

×=
×
N0⁼?ȯȧ?"
ḃ3%3’
0Çḅ3$$⁼¥1#ḢÇṚµ€z0Z⁹+2¤ŀ/Ṛḅ3

इसे ऑनलाइन आज़माएं!

पूरा कार्यक्रम।

-1= C, 0= A, 1=B

तर्क 1: [x, y]
तर्क 3:z

Comments

मैं ले जा नहीं लगता कि xऔर yसंतुलित त्रिगुट में अनुमति दी है: "x और y -3812798742493 से 3812798742493 समावेशी करने के लिए किया जा सकता है पहला कदम संतुलित त्रिगुट के लिए दशमलव से x और y कन्वर्ट करने के लिए है।।"

— जोनाथन एलन

@JonathanAllan टिप्पणी स्पष्टीकरण

— एरिक आउटगोलर

... लेकिन संख्याओं के लिए मूल प्रारूप जेली में संतुलित नहीं है।

— जोनाथन एलन

@JonathanAllan ओह, ऐसा लग रहा है कि मुझे गलत समझा गया है ...

— एरिक द आउटग्रोफर

@JonathanAllan eugh ... फिक्स्ड

— एरिक आउटगोल्फर