41

Malbolge प्रोग्रामिंग भाषा की कई विशिष्ट विशेषताओं में से एक इसका अत्यधिक अनपेक्षितOP ऑपरेटर है, जिसे केवल प्रलेखन और स्रोत कोड में "op" के रूप में संदर्भित किया जाता है, लेकिन लोकप्रिय रूप से इसे "पागल" ऑपरेटर के रूप में जाना जाता है। जैसा कि इसके दस्तावेज में, भाषा के निर्माता, बेन ओल्मस्टेड द्वारा वर्णित किया गया है: " पैटर्न की तलाश मत करो, यह वहां नहीं है ।"

ऑप एक "ट्राइटवाइज" ऑपरेटर है - यह अपने दो तर्कों के संबंधित त्रैमासिक अंकों पर कार्य करता है। प्रत्येक ट्रिट (टर्नरी बिट) के लिए, ऑप का परिणाम निम्न लुकअप टेबल द्वारा दिया गया है:

           a
op(a,b)  0 1 2
       +-------
     0 | 1 0 0
   b 1 | 1 0 2
     2 | 2 2 1

उदाहरण के लिए, गणना करने के लिए op(12345, 54321), पहले टर्नरी में दोनों संख्याओं को लिखें और फिर तालिका में प्रत्येक जोड़ी को देखें:

   0121221020   (12345_3)
op 2202111220   (54321_3)
--------------
   2202220211   (54616_3)

पिछले महत्वपूर्ण मुद्दा यह है कि Malbolge में सभी मान तो इनपुट मानों से 10 की चौड़ाई के लिए शून्य के साथ गद्देदार किया जाना चाहिए 10 trits विस्तृत, कर रहे हैं (उदाहरण के लिए, op(0, 0)है 1111111111त्रिगुट में।)

आपका कार्य इनपुट के रूप में दो पूर्णांक 0 is a, b<59049 लेना है और पूर्णांक मान को आउटपुट करना है op(a,b)।

परीक्षण मामलों (प्रारूप में a b op(a,b)):

0 0 29524
1 2 29525
59048 5 7
36905 2214 0
11355 1131 20650
12345 54321 54616

यहां एक संदर्भ कार्यान्वयन (मालबोज स्रोत कोड से सीधे कॉपी किया गया) है।

code-golf number

— Doorknob
स्रोत

28

इसका जवाब मालबोगे में दिया जा सकता है? ;)

— प्रदर्शित नाम

3

मुझे लगता है कि Malbolge अब एक अच्छी गोल्फिंग भाषा है!

— एथन

7

इसके लायक क्या है, 54616_3इसका मतलब यह नहीं है "यह दूसरी बात दशमलव संख्या 54616 है, लेकिन इसे आधार तीन के रूप में दर्शाया गया है"। इसका अर्थ है " 54616आधार 3 के रूप में पढ़ें "। जो, निश्चित रूप से, आप ऐसा नहीं कर सकते हैं (ऐसे अंक हैं जो वाल्व वहाँ नहीं गिन सकते हैं)। यदि आप _3पूरी तरह से छुटकारा पा चुके हैं , और अधिक सटीक है, तो यह अभी भी शायद उतना ही स्पष्ट होगा ।

— निक हार्टले

@ ऑरेंजसैंडमलेन्स का अनुमान है कि मैं मालबोज में ऑपरेटर का उपयोग करके मानक खामियों के तहत गिरूंगा। अलग कोड का उपयोग करके इसे फिर से लागू करना ठीक होगा।

— पाओलो एबरमन

7

@ Pa @loEbermann नहीं, यह एक बचाव का रास्ता नहीं है ।

— user202729

43

सी (जीसीसी) , 99 98 96 बाइट्स

छत के लिए धन्यवाद एक बाइट को बचाया ; गोल्फ 19683के लिए L'䳣'।
दो बाइट्स बचाए; गोल्फ 108609के लिए L'𚡁'।

M,a,l,b,o;L(g,e){for(o=b=L'䳣',l=0;o/=2.4;b/=3)M=g/b,g%=b,a=e/b,e%=b,l+=b*(L'𚡁'>>M+6*a+M&3);g=l;}

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

— जोनाथन फ्रेच
स्रोत

14

मुझे नामकरण योजना पसंद है!

— मैथ्यू एम।

28

जावास्क्रिप्ट (ईएस 7), 56 बाइट्स

f=(a,b,k=9)=>~k&&(a%3|b%3<<9|8)**2%82%3+3*f(a/3,b/3,k-1)

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

कैसे?

में और को देखते हुए , हम गणना करते हैं: $a$ $b$ $[0..2]$

f (a, b) = ((a + 512 b + 8)^{2} mod 82) mod 3

$f(a,b)=((a+512b+8)^2 \bmod 82) \bmod 3$

के लिए अग्रणी:

 a | b | 512b | a + 512b |  + 8 | squared | MOD 82 | MOD 3
---+---+------+----------+------+---------+--------+-------
 0 | 0 |    0 |      0   |    8 |      64 |   64   |   1                  a
 1 | 0 |    0 |      1   |    9 |      81 |   81   |   0                0 1 2
 2 | 0 |    0 |      2   |   10 |     100 |   18   |   0              +-------
 0 | 1 |  512 |    512   |  520 |  270400 |   46   |   1            0 | 1 0 0
 1 | 1 |  512 |    513   |  521 |  271441 |   21   |   0    -->   b 1 | 1 0 2
 2 | 1 |  512 |    514   |  522 |  272484 |   80   |   2            2 | 2 2 1
 0 | 2 | 1024 |   1024   | 1032 | 1065024 |    8   |   2
 1 | 2 | 1024 |   1025   | 1033 | 1067089 |   23   |   2
 2 | 2 | 1024 |   1026   | 1034 | 1069156 |   40   |   1

समारोह का विकल्प

प्रपत्र के कई अन्य संभावित उम्मीदवार हैं:

f_{k, c, p, m} (a, b) = ((a + k b + c)^{p} mod m) mod 3

$f_{k,c,p,m}(a,b)=((a+kb+c)^p \bmod m) \bmod 3$

सबसे कम लोगों में से एक:

f (a, b) = ((a + 5 b + 2)^{4} mod 25) mod 3

$f(a,b)=((a+5b+2)^4 \bmod 25) \bmod 3$

लेकिन बारे में अच्छी बात यह है कि इसे बिटवाइज़ ऑपरेटरों के साथ किया जा सकता है, इस प्रकार यह और के दशमलव भागों को स्पष्ट रूप से छोड़ देता है । यही कारण है कि हम बस प्रत्येक पुनरावृत्ति के बीच गोलाई के बिना उन्हें विभाजित कर सकते हैं । $(a+512b+8)$ $a$ $b$ $3$

टिप्पणी की गई

f = (a, b,            // given the input integers a and b
           k = 9) =>  // and starting with k = 9
  ~k &&               // if k is not equal to -1:
    ( a % 3           //   compute (a mod 3)
      | b % 3 << 9    //   add 512 * (b mod 3)
      | 8             //   add 8
    ) ** 2            //   square the result
    % 82              //   apply modulo 82
    % 3               //   apply modulo 3, leading to crazy(a % 3, b % 3)
    + 3 * f(          //   add 3 times the result of a recursive call with:
      a / 3,          //     a / 3  \__ no rounding required
      b / 3,          //     b / 3  /   (see 'Function choice')
      k - 1           //     k - 1
    )                 //   end of recursive call

— Arnauld
स्रोत

मुझे लगता (1581093>>b%3*2+a%3*8&3)है कि एक पूरी बाइट बचाता है!

— नील

@ नील, दुर्भाग्य से, मैं गुजर रहा हूं a/3और b/3बिना गोल किए। उस वजह से असफल हो जाएगा।

— अर्नुलद

9

दिलचस्प है कि आपको एक पैटर्न कैसे मिला जो मौजूद नहीं है।

— निकोल निकोल

क्या पसंद k = 9 ... => ~k && ...करने का कोई कारण है k = 10 ... => k && ...?

— फाल्को

1

@Falco नहीं, यह किसी भी तरह से कम या अधिक कुशल नहीं है। मैं तो बस इसलिए मैं नहीं बल्कि नकल था, 0-अनुक्रमित सामान पसंद करते हैं चाहते हैं for(k=9;k>=0;k--)की तुलना में for(k=10;k>=1;k--)।

— अरनुलद

13

05AB1E , 18 बाइट्स

कोड:

3Tm+3Bø5+3m5(^3%3β

05AB1E एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

एल्गोरिथम स्पष्टीकरण

शून्य से गद्देदार संख्या प्राप्त करने के लिए, हमें 59049 को दोनों संख्याओं को जोड़ने की आवश्यकता है (क्योंकि ternary में 59049 10000000000 है )। हम अग्रणी बाहर छोड़ने के लिए नहीं है 1 के रूप में । हम दशमलव से संख्याओं को त्रिगुट में बदलते हैं और प्रत्येक जोड़े को प्रत्येक संख्या के रूप में जोड़ते हैं। $(1, 1) \rightarrow 0$

उदाहरण के लिए, इनपुट के लिए 12345 और 54321 , इनसे मैप किया जाता है:

\begin{matrix} 12345 \to & 1 & 0 & 1 & 2 & 1 & 2 & 2 & 1 & 0 & 2 & 0 \\ 54321 \to & 1 & 2 & 2 & 0 & 2 & 1 & 1 & 1 & 2 & 2 & 0 \end{matrix}

$\begin{array} & 12345 \rightarrow & 1 & 0 & 1 & 2 & 1 & 2 & 2 & 1 & 0 & 2 & 0 \\ 54321 \rightarrow & 1 & 2 & 2 & 0 & 2 & 1 & 1 & 1 & 2 & 2 & 0 \end{array}$

जो कि पूर्णांक में निम्नलिखित सूची देता है:

11, 2, 12, 20, 12, 21, 21, 11, 2, 22, 0

$11, 2, 12, 20, 12, 21, 21, 11, 2, 22, 0$

इन पूर्णांकों को ओपी में दिए गए लुकअप टेबल द्वारा मैप किया जाना चाहिए। वर्तमान में हम इन नंबरों का उपयोग उनके संगत ट्रिट्स ( ) के लिए करते हैं: $0 \rightarrow 1, 10 \rightarrow 0, \dots$

f (x) = ((x + 5)^{3} \oplus - 5) mod 3

$f(x) = \left((x + 5)^3 \oplus -5\right) \text{ mod }3$

जबकि बिटवाइज़ को दर्शाता है XOR समारोह। $\oplus$

अंततः इस फ़ंक्शन को शामिल किए गए पूर्णांक की सूची पर मैप करने के बाद, हम इस परिणामी सूची को आधार 3 में दर्शाए गए नंबर के रूप में मानते हैं और इसे आधार 3 से दशमलव में परिवर्तित करते हैं।

कोड स्पष्टीकरण

3Tm+                  # Add 59049 to pad the ternary number with zeroes.
    3B                # Convert to base 3.
      ø               # Zip the list to get each joined integer.
       5+             # Add 5 to each element.
         3m           # Raise each element to the power of 3.
           5(^        # XOR each element with -5.
              3%      # Modulo each element with 3.
                3β    # Convert from base 3 to decimal.

— अदनान
स्रोत

3Tm+3Bø19sm74%3%3βगोल्फ हो सकता है?

— जोनाथन एलन

@JonathanAllan अच्छा लगा! हालाँकि यह किसी भी अन्य प्रकार के काले जादू के फार्मूले का उपयोग किए बिना इसे और अधिक असंभव करना है।

— अदनान

11

आर , 64 62 बाइट्स

function(a,b,x=3^(9:0))30801%/%x[a%/%x%%3*3+b%/%x%%3+1]%%3%*%x

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

कुछ ~~काले जादू~~ गोल्फ चाल और -2 बाइट्स के लिए JAD का धन्यवाद !

30801, जब एक 10-ट्रिट टर्नरी पूर्णांक में परिवर्तित हो जाता है, 1120020210जो कि कॉलम के नीचे पढ़ने पर बस एक अनुगामी शून्य को ऑपरेशन टेबल में जोड़ता है। फिर हम की त्रिगुट अंक कन्वर्ट aऔर bइस बात का त्रिगुट अंकों में एक सूचकांक के रूप में एक पूर्णांक और उपयोग में elementwise 30801।

— ग्यूसेप
स्रोत

1

ऑपरेटर पूर्वता के लिए 62 बाइट्स याय!

— JAD

1

हाँ, इस तरह, आप पहली बार इंडेक्स xका उपयोग कर रहे हैं [.*]। फिर सभी %any%ऑपरेशन होते हैं। मजेदार बात यह है कि यदि आप देखते हैं 30801%/%x%%3के रूप में f=function(x)30801%/%x%%3, कि f(x[index]) == (f(x))[index]। ब्रेसिज़ बचाना :)

— JAD

@ जद आकर्षक! और जैसा कि मैं ऊपर टिप्पणी करता हूं, मूल रूप से काला जादू।

— ग्यूसेप

1

मैं ख़ुशी से स्वीकार करूँगा कि इसने बहुत कुछ तय किया: P

— JAD

10

सी (जीसीसी) , 74 72 71 बाइट्स

f(a,b,i,r){for(r=0,i=59049;i/=3;)r+=(108609>>a/i%3*2+b/i%3*6&3)*i;i=r;}

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

टूट - फूट

सत्य सारणी

           a
op(a,b)  0 1 2
       +-------
     0 | 1 0 0
   b 1 | 1 0 2
     2 | 2 2 1

एक 3x3 सरणी के रूप में सोचा जा सकता है, जहां एक कॉलम है, और बी पंक्ति है। एक आयामी सूची में परिवर्तित करना हमें 100102221 देता है। अंतरिक्ष को बचाने के लिए हम सूचियों और तारों से बचते हैं और इसके बजाय एक संख्या में बनाते हैं। ऐसा करने के लिए, हम ऑर्डर को फ्लिप करते हैं और हर ट्रिट को 2-बिट संख्या में बदलते हैं। उन्हें एक साथ गोंद करें और हमारे पास एक बाइनरी संख्या है जिसे हम "इंडेक्स" में दाईं ओर 2 * (b * 3 + a)घुमाकर और मास्किंग करके कर सकते हैं :

 1 0 0 1 0 2 2 2 1
 1 2 2 2 0 1 0 0 1
011010100001000001

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

3 ^ 9 = 19683 ताकि एक अच्छी लूप सीमा हो। चूंकि हम हर बार काउंटर को 3 से गुणा करते हैं, इसलिए हम 2e4इसके बजाय सीमा लिख सकते हैं । इसके अलावा, हम खुद को pow()या इसी तरह की परेशानियों से बचाते हैं ।

दूसरे विचार पर, चलो 3 ^ 10 से शुरू करते हैं और प्री-लूप डिवाइड-एंड-टेस्ट के साथ नीचे की ओर काम करते हैं।

— gastropner
स्रोत

8

हास्केल , 108 बाइट्स

2%2=1
_%2=2
0%_=1
2%1=2
_%_=0
g=take 10.map(`mod`3).iterate(`div`3)
(foldr((.(3*)).(+))0.).(.g).zipWith(%).g

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

— गेहूं का जादूगर
स्रोत

7

APL (Dyalog) , 41 25 बाइट्स

9 बाइट्स @ Adám की बदौलत बच गए

3⊥(b⊤6883)[3⊥⍉⎕⊤⍨3,b←9⍴3]

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

— Uriel
स्रोत

उल्टे क्रम में इनपुट लेता है, 25 बाइट्स:3⊥(b⊤6883)[3⊥⍉⎕⊤⍨3,b←9⍴3]

— Adám

@ Adám धन्यवाद! यह कुछ साफ-सुथरा सामान है। मुझे लगता है कि मैं थोड़ा कठोर हो गया हूं: पी

— उरियल

6

जेली , 23 18 बाइट्स

-1 एरिक Outgolfer करने के लिए धन्यवाद (पुनर्व्यवस्थित 3*⁵¤करने के लिए ⁵3*)

⁵3*+b3Zḅ3ị⁽½Ṡb3¤ḅ3

दो पूर्णांकों की सूची को स्वीकार करने वाला एक अद्वैतिक लिंक।

इसे ऑनलाइन आज़माएं! या एक परीक्षण-सूट देखें ।

⁹*%733%3एक बाइट से अधिक लंबा है ị⁽½Ṡb3¤:(

कैसे?

⁵3*+b3Zḅ3ị⁽½Ṡb3¤ḅ3 - Link: [a, b]      e.g. [11355,1131]
⁵                  - literal ten            10
 3                 - literal three          3
  *                - exponentiation         59049
   +               - addition (vectorises)  [70404,60180]
     3             - literal three          3
    b              - to base (vectorises)   [[1,0,1,2,0,1,2,0,1,2,0],[1,0,0,0,1,1,1,2,2,2,0]]
      Z            - transpose              [[1,1],[0,0],[1,0],[2,0],[0,1],[1,1],[2,1],[0,2],[1,2],[2,2],[0,0]]
        3          - literal three          3
       ḅ           - from base (vectorises) [4,0,3,6,1,4,7,2,5,8,0]
               ¤   - nilad followed by link(s) as a nilad:
          ⁽½Ṡ      -   literal 3706         3706
              3    -   literal three        3
             b     -   to base              [1,2,0,0,2,0,2,1]
         ị         - index into             [0,1,0,0,1,0,2,2,2,1,1]
                 3 - literal three          3
                ḅ  - from base              20650

इसके अलावा 18: ⁵3*+b3ZḌ19*%74%3ḅ3(आधार दस तो है कि सत्ता में 19 लेने से परिवर्तित करने की जोड़ी के लिहाज से trits प्राप्त करने के बाद एक जादू-सूत्र का उपयोग करता, 74 सापेक्ष, सापेक्ष 3 उत्पादन के लिए जरूरी trits पाने के लिए - पाया पायथन में एक खोज का उपयोग करके)

— जोनाथन एलन
स्रोत

18 बाइट्स (ध्यान दें: वास्तव में एक "प्रीपेंड y 0एस" बिल्ट-इन होना चाहिए )

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

ऊह मैंने सोचा कि अजीब लग रहा था। धन्यवाद!

— जोनाथन एलन

कई चीजें अजीब लगती हैं, कभी-कभी आपको उनकी आदत डालनी पड़ती है। : पी

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

5

पायथन 2 , 79 65 63 61 बाइट्स

अपने फॉर्मूले (-2 बाइट्स) के लिए अरनुलद को धन्यवाद ।

f=lambda a,b,i=9:i+1and(a%3+b%3*5+2)**4%25%3+f(a/3,b/3,i-1)*3

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

— OVS
स्रोत

4

जे , 37 बाइट्स

((3 3$d 30801){~{@,.)&.(d=.(10$3)&#:)

स्पष्टीकरण:

((3 3$d 30801){~{@,.)&.(d=.(10$3)&#:)   
                       (d=.(10$3)&#:)   convert to 10 trits, and name this function as d
                     &.                 ... which is done on both args and inverted on the result
                {@,.                    make boxed indices: 1 2 3 4 {@,. 5 6 7 8  ->  1 5 ; 2 6 ; 3 7 ; 4 8
              {~                        index out of a lookup table
 (3 3$d 30801)                          reusing the trits conversion function to make the table

अपेक्षाकृत पठनीय, tbh समाप्त हुआ।

— घूंट
स्रोत

PPCG में आपका स्वागत है! यहाँ एक परीक्षण-सूट है - मैंने गैलेन इवानोव के जवाब से रैपिंग कोड चुरा लिया।

— जोनाथन एलन

PPCG के लिए वेलकम! अच्छा समाधान! यहां एक TIO लिंक दिया गया है।

— गैलेन इवानोव

30

— FrownyFrog

2

28

— FrownyFrog

@FrownyFrog अच्छा है!

— योना

3

पायथन 2 , 90 87 बाइट्स

f=lambda a,b,A='':f(a/3,b/3,'100102221'[a%3+b%3*3]+A)if a+b else int(A.rjust(10,'1'),3)

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

— चास ब्राउन
स्रोत

3

चारकोल , 31 बाइट्स

Ｉ↨³⮌⭆χ§200211⁺∨﹪÷θＸ³ι³¦⁴﹪÷ηＸ³ι³

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

     χ                          Predefined variable 10
    ⭆                           Map over implicit range and join
                    ι        ι  Current index
                  Ｘ³       Ｘ³   Power of 3
                 θ              Input `a`
                          η     Input `b`
                ÷        ÷      Integer divide
               ﹪     ³  ﹪     ³ Modulo by 3
              ∨       ¦⁴        Replace zero ternary digit of `a` with 4
             ⁺                  Add
      §200211                   Index into literal string `200211`
   ⮌                            Reverse
 ↨³                             Convert from base 3
Ｉ                               Cast to string
                                Implicitly print

वैकल्पिक समाधान, 31 बाइट्स:

Ｉ↨³Ｅ↨⁺Ｘ³χθ³§200211⁺∨ι⁴§↨⁺Ｘ³χη³κ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है।

        χ                  χ    Predefined variable 10
      Ｘ³                 Ｘ³     Power of 3 i.e. 59049
         θ                      Input `a`
                            η   Input `b`
     ⁺                  ⁺       Sum
    ↨     ³            ↨     ³  Convert to base 3
   Ｅ                            Map over elements
                    ι           Current ternary digit of `a`
                   ∨ ⁴          Replace zero with 4
                      §       κ Index into ternary digits of `b`
                  ⁺             Add
           §200211              Index into literal string `200211`
 ↨³                             Convert from base 3
Ｉ                               Cast to string
                                Implicitly print

— नील
स्रोत

2

रूबी , 70 बाइट्स

->a,b,l=10{l>0?6883.digits(3)[8-b%3*3-a%3]*3**(10-l)+f[a/3,b/3,l-1]:0}

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

जब तक हम प्रत्येक के 10 अंक प्राप्त नहीं करते तब तक पुन: प्रस्ताव aऔर bपुनरावृत्ति। 6883चपटा टर्नरी टेबल (उलट) देता है। गुणा से दशमलव तक टर्नरी से पुनर्निर्माण 3**(10-l)।

— crashoz
स्रोत

2

Cjam, 31 बाइट्स

{{3bA0e[\}2*.{3*+"100102221"=}}

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

— क्रोमियम
स्रोत

2

जे , 43 बाइट्स

3#.((3 3$t 6883){~<@,~"0)&(_10{.t=.3&#.inv)

यह निश्चित रूप से आगे गोल्फ हो सकता है।

स्पष्टीकरण:

                         &(               ) - for both arguments
                                t=.3&#.inv  - convert to base 3 (and name the verb t)
                           _10{.            - pad left with zeroes
   (              <@,~"0)                   - box the zipped pairs (for indexing)
    (3 3$t 6883)                            - the lookup table
                {~                          - use the pairs as indeces in the table
3#.                                         - back to decimal

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

— गैलेन इवानोव
स्रोत

2

स्टेक्स , 22 बाइट्स

é╨¼aûé∟ç⌂zπb![5┬◘«╜‼╞♠

इसे चलाएं और डीबग करें

— wastl
स्रोत

2

पायथ 26 25 24 बाइट्स

सहेजे गए 1 बाइट, @ErikTheOutgolfer के लिए धन्यवाद

@ JonathanAllan के उत्तर से प्रेरित एक और बाइट बचाएं

im@j3422 3id3Cm.[0Tjd3Q3

इनपुट एक 2 तत्व सूची है [a,b]। इसे यहाँ ऑनलाइन आज़माएँ , या यहाँ सभी परीक्षण मामलों को सत्यापित करें ।

im@j3422 3id3Cm.[0Tjd3Q3   Implicit: Q=eval(input())
              m       Q    Map each element d of the input using:
                   jd3       Convert to base 3
               .[0T          Pad to length 10 with 0's
             C             Transpose
 m                         Map each element d of the above using:
   j3422 3                   The lookup table [1,1,2,0,0,2,0,2]
  @                          Modular index into the above using
          id3                Convert d to base 10 from base 3
i                      3   Convert to base 10 from base 3, implicit print

— सोक
स्रोत

.Tहो सकता है C।

— आउटगोल्फ

2

के (ngn / k) , 25 22 बाइट्स

3/(3\10267)@3/+(10#3)\

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

— NGN
स्रोत

1

जाप , 24 23 बाइट्स

महीने की भाषा के रूप में जाप के रन पर गेंद को लुढ़कना - मुझे पूरी तरह से इस पर आउट होने की उम्मीद है!

एक पूर्णांक सरणी (यानी, [b,a]) के रूप में रिवर्स ऑर्डर में इनपुट लेता है ।

ms3 ùTA y_n3 g6883ì3Ãì3

कोशिश करो

ms3 ùTA y_n3 g6883ì3Ãì3      :Implicit input of array U=[b,a]
m                            :Map
 s3                          :  Convert to base-3 string
    ù                        :Left pad each
     T                       :  With zero
      A                      :  To length 10
        y                    :Transpose
         _                   :Map
          n3                 :  Convert from base-3 string to decimal
             g               :  Index into
              6883ì3         :    6883 converted to a base-3 digit array
                    Ã        :End map
                     ì3      :Convert from base-3 digit array to decimal

— झबरा
स्रोत

0

पर्ल 5 `-p` , 102 बाइट्स

sub t{map{("@_"%3,$_[0]/=3)[0]}0..9}@a=t$_;@b=t<>}{$\=(1,1,2,0,0,2,0,2,1)[(3*pop@a)+pop@b]+$\*3while@a

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

— Xcali
स्रोत

0

वोल्फ्राम लैंग्वेज (मैथेमेटिका) , 75 72 60 बाइट्स

(d=IntegerDigits)[6883,3][[{1,3}.d[#,3,10]+1]]~FromDigits~3&

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

बिना गोल्फ वाला संस्करण:

M[{a_, b_}] := 
  FromDigits[{1, 0, 0, 1, 0, 2, 2, 2, 1}[[
    IntegerDigits[a, 3, 10] + 3*IntegerDigits[b, 3, 10] + 1
  ]], 3];

दोनों aऔर bदस trit सूचियों, तो संख्या का एक लुकअप तालिका में एक 2 डी सूचकांक के रूप में इस्तेमाल जोड़ो में करने के लिए परिवर्तित कर रहे हैं {1, 0, 0, 1, 0, 2, 2, 2, 1}। परिणाम को फिर से दस-ट्रिट सूची के रूप में व्याख्या किया जाता है और पूर्णांक रूप में परिवर्तित किया जाता है।

लुकअप टेबल को कोड किया गया है IntegerDigits[6883,3], जो कि छोटा है क्योंकि हम IntegerDigitsप्रतीक को पुनर्चक्रित कर रहे हैं ।

— रोमन
स्रोत

Malbolge के "पागल" ऑपरेटर को लागू करें

सी (जीसीसी) , 99 98 96 बाइट्स

जावास्क्रिप्ट (ईएस 7), 56 बाइट्स

कैसे?

समारोह का विकल्प

टिप्पणी की गई

05AB1E , 18 बाइट्स

कोड:

एल्गोरिथम स्पष्टीकरण

कोड स्पष्टीकरण

आर , 64 62 बाइट्स

सी (जीसीसी) , 74 72 71 बाइट्स

टूट - फूट

हास्केल , 108 बाइट्स

APL (Dyalog) , 41 25 बाइट्स

जेली , 23 18 बाइट्स

कैसे?

पायथन 2 , 79 65 63 61 बाइट्स

जे , 37 बाइट्स

पायथन 2 , 90 87 बाइट्स

चारकोल , 31 बाइट्स

रूबी , 70 बाइट्स

Cjam, 31 बाइट्स

जे , 43 बाइट्स

स्पष्टीकरण:

स्टेक्स , 22 बाइट्स

पायथ 26 25 24 बाइट्स

के (ngn / k) , 25 22 बाइट्स

जाप , 24 23 बाइट्स

पर्ल 5 -p , 102 बाइट्स

वोल्फ्राम लैंग्वेज (मैथेमेटिका) , 75 72 60 बाइट्स

पर्ल 5 `-p` , 102 बाइट्स