INTERCAL के बाइनरी ऑपरेटर्स को लागू करें

Question

संकलक भाषा जिसके साथ कोई मान्यता नहीं है, संक्षिप्त रूप में , INTERCAL , एक बहुत ही अनोखी प्रोग्रामिंग भाषा है। इसके अप्रतिबंधित गुणों में इसके बाइनरी ऑपरेटर हैं।

INTERCAL के दो द्विआधारी ऑपरेटर हैं Interleave (भी रूप में जाना जाता Mingle ), और चयन । इंटरलीव को एक परिवर्तन (ve) के साथ दर्शाया गया है, और चयन को एक वर्ग (~) के साथ दर्शाया गया है।

इंटरलीव 0-65535 में दो नंबर लेकर और उनके बिट्स को वैकल्पिक करके काम करता है। उदाहरण के लिए:

234 ¢ 4321
234   = 0000011101010
4321  = 1000011100001
Result: 01000000001111110010001001
Output: 16841865

0-65535 की सीमा में दो नंबर लेकर, पहले ऑपरेंड में बिट्स लेते हुए काम का चयन करें, जो दूसरे ऑपरेंड में 1s के समान स्थिति में हैं, और उन बिट्स को राइट पैकिंग करते हैं।

2345 ~ 7245
2345  = 0100100101001
7245  = 1110001001101
Taken : 010   0  10 1
Result: 0100101
Output: 37

इस चुनौती में, आपको इंटरलेव या चयन ऑपरेशन का उपयोग करके एक द्विआधारी अभिव्यक्ति दी जाएगी। आपको सबसे कम संभव बाइट्स का उपयोग करके परिणाम की गणना करनी चाहिए।

अभिव्यक्ति या तो एक अंतरिक्ष अलग स्ट्रिंग के रूप में दिया जाएगा 0-65,535, एक अंतरिक्ष में एक पूर्णांक से मिलकर, ¢या ~, एक जगह है, और 0-65,535 में एक पूर्णांक।

इनपुट और आउटपुट किसी भी मानक प्रणाली (STDIN, फ़ंक्शन, कमांड लाइन, आदि) के माध्यम से हो सकता है। मानक खामियों पर रोक लगाई।

उदाहरण:

5 ¢ 6
54

5 ~ 6
2

51234 ¢ 60003
4106492941

51234 ~ 60003
422

यह कोड गोल्फ है - सबसे कम बाइट्स जीतता है। सौभाग्य।

संपादित करें: चूंकि कुछ भाषाएं INTERCAL के परिवर्तन (,) प्रतीक का समर्थन नहीं करती हैं, आप 5 बाइट के दंड के बजाय बड़े धन ($) प्रतीक का उपयोग कर सकते हैं।

Comments

यह डॉलर के चिह्न के उपयोग के लिए लोगों को दंडित करने के लिए थोड़ा कठोर है। यह एक ऐसी चीज है जिसकी मदद नहीं की जा सकती।

— बीटा क्षय

मुझे अभी पता चला है कि CLWNPA वेल्श में पूरी तरह से उच्चारण योग्य है। डब्ल्यू को स्पेनिश में यू या अंग्रेजी में ऊ कहा जाता है।

— लेवल रिवर सेंट

मुझे 5 बाइट का जुर्माना नहीं मिला है। सी-INTERCAL का उपयोग करता है $।

— kirbyfan64sos

आप सभी किस बारे में बहस कर रहे हैं? एक $ स्पष्ट रूप से एक expensive की तुलना में महंगा है। क्या, आप कुछ नहीं के लिए 99 ¢ चाहते हैं?

— अधिकतम

मुझे नहीं लगता था कि INTERCAL आपको दशमलव अंकों के साथ संख्याओं को इनपुट करने की अनुमति देगा। क्या आपको लिखना नहीं आता FIVE ONE TWO THREE FOUR? और आउटपुट रोमन अंकों में नहीं होना चाहिए?

— नैट एल्ड्रेडगे

Answer 1

पायथ, 32 31 29 बाइट्स

isummFdG}\~zCm.[Z16jvd2%2cz)2

इसे ऑनलाइन आज़माएं: नियमित इनपुट / टेस्ट सूट

एक बाइट को बंद करने के लिए @isaacg को धन्यवाद।

स्पष्टीकरण:

                         cz)   split input at spaces
                       %2      only take every second item (the numbers)
             m                 map each number d to:
                    vd           convert d to int
                   j  2          convert to base 2
              .[Z16              pad zeros at the left
            C                  zip
  u     }\~z                   apply the following function ("~" in input) times:
   m   G                         map each pair d to:
    mFd                          convert [x,0] to [] and [x,1] to [x]
 s                             take sum (unfold all lists)
i                           2  convert back from base 2 and print

Comments

आप को बदलने के द्वारा एक बाइट बचा सकते हैं hMfeTकरने के लिए smmFdऔर फिर डुप्लिकेट चलती sबाहर त्रिगुट। इसके अलावा, आपका वर्तमान कोड 32 बाइट्स है, न कि 33.

— isaacg

@ आइसाकग वाह। मैंने कभी नहीं सोचा होगा कि चालाक गोल्फ। धन्यवाद। और हाँ, स्पष्टीकरण लिखते समय एक आखिरी मिनट गोल्फ किया और बाइट गिनती को अपडेट नहीं किया।

— जकूबे

पाइथ और सीजाम के उत्तर देखना वास्तव में दिलचस्प है, लगभग हमेशा एक ही बाइट काउंट, लेकिन पाइथ अक्सर सीजेम को कुछ से

— हरा देता है

Answer 2

पायथन 2, 115 112 बाइट्स

x,y,z=input().split()
d=y<""
f=lambda a,b:a+b and(b%2+5&4-d)*f(a/2,b/2)+(a%2*2+b%2)/3**d
print f(int(x),int(z))

दूसरी पंक्ति की स्ट्रिंग में एक एकल छाप पात्र होता है \x7d, उसके बाद अगला चार ~।

एक अच्छे, एकल लैम्ब्डा की सभी उम्मीदें इनपुट प्रारूप द्वारा कुचल दी जाती हैं। इनपुट में पढ़ने का एक बेहतर तरीका शायद है। "51234 ¢ 60003"STDIN के माध्यम से इनपुट की तरह ।

फ़ंक्शन fनिम्नलिखित दो पुनरावर्ती कार्यों को जोड़ता है:

g=lambda a,b:a+b and 4*g(a/2,b/2)+a%2*2+b%2    # ¢
h=lambda a,b:a+b and(b%2+1)*h(a/2,b/2)+a*b%2   # ~

(@ बर्नोर की मदद से -3 बाइट्स)

Comments

पहले वास्तव में प्रतिस्पर्धी पायथन जवाब के लिए +1। मैं सोच रहा था कि आपने लंबोदर से क्यों परेशान किया और सिर्फ एक अभिव्यक्ति का उपयोग नहीं किया, लेकिन ऐसा लगता है कि वहां कुछ पुनरावृत्ति हो रही है? मैं अजगर को नहीं जानता, मैं एक स्पष्टीकरण के लिए तत्पर हूं।

— लेवल रिवर सेंट

कुछ महान सा कोसने! मैं निरंतर शब्द अभिव्यक्ति को संपीड़ित कर रहा हूं। अभिव्यक्ति (a%2*2+b%2)/3**d3 वर्णों को बचाता है लेकिन पूरक का उपयोग करता है d=1-c। क्या आपके पास -~(3*c|b%2)पूरक के साथ करने का एक तरीका है ? सबसे खराब स्थिति में यह 2 चार्ट खो देता है 3-3*d। इसके अलावा, प्रारूप एक प्रतीक या संख्या के साथ शुरू and-~x+yहोने andy-~xतक लंबा हो सकता है y।

— xnor

@xnor समझ गया (b%2+5&4-d),। धन्यवाद!

— Sp3000

Answer 3

सीजेएम, 31 बाइट्स

rrc\r]{i2bF0e[}%(7=\zf{_)*?~}2b

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

यह काम किस प्रकार करता है

rr                              e# Read two tokens from STDIN.
  c\                            e# Cast the second to char and swap with the first.
    r                           e# Read a third token from STDIN.
     ]                          e# Wrap everything in an array.
      {       }%                e# For all three elements:
       i2b                      e#   Cast to int and convert to base 2.
          F0e[                  e#   Left-pad with zeroes to complete 15 digits.
                (               e# Shift out the first base 2 array.
                 7=             e# Select its eighth MSB (1 for '¢', 0 for '~').
                   \            e# Swap with the array of base 2 arrays.
                    z           e# Zip to transpose rows with columns.
                     f{     }   e# For each pair of base 2 digits:
                                e#   Push the bit, then the pair.
                       _        e#   Copy the pair.
                        )       e#   Pop the second digit.
                         *      e#   Repeat the first digit that many times.
                          ?     e#   Ternary if. Select the pair if the bit is
                                e#    truthy, the repeated first bit if it's falsy.
                           ~    e#   Dump the selected array on the stack.
                             2b e# Convert from base 2 to integer.

Answer 4

जावास्क्रिप्ट (ईएस 6), 103 117 119 124

अब स्ट्रिंग्स के बजाय संख्याओं के साथ काम करना संपादित करें

(प्रमुख रिक्त स्थान, newlines और टिप्पणियों की गिनती नहीं)

किसी भी EcmaScript 6 अनुरूप ब्राउज़र पर स्निपेट का परीक्षण करना (विशेष रूप से क्रोम नहीं MSIE। मैंने फ़ायरफ़ॉक्स, सफारी 9 पर परीक्षण किया जा सकता है)।

I=s=>
  (i=>{
    for(m=r=0,[a,o,b]=s.split` `;i>0;i<<=1) // loop until bit 31 of i is set
      o>'~'?r+=(b&i)*i+(a&i)*2*i:b&i?r+=(a&i)>>m:++m
  })(1)||r


// TEST
out=x=>O.innerHTML+=x+'\n\n';

[ ['234 ¢ 4321', 16841865], ['2345 ~ 7245', 37]
, ['5 ¢ 6', 54], ['5 ~ 6', 2]
, ['51234 ¢ 60003',4106492941], ['51234 ~ 60003', 422]]
.forEach(([i,o,r=I(i)])=>{
  out('Test '+ (o==r?'OK':'Fail')+'\nInput:    '+ i+'\nResult:   '+r+'\nExpected: '+o)})

<pre id=O></pre>

Answer 5

मतलाब, 119 113 बाइट्स

function f(s)
t=dec2bin(str2double(strsplit(s,{'¢' '~'}))');u=any(s>'~');[~u u]*bin2dec({t(1,t(2,:)==49) t(:)'})

Ungolfed:

function f(s)                                     % input s is a string
t = dec2bin(str2double(strsplit(s,{'¢' '~'}))');  % get the two numbers and convert to
                                                  % two-row char array of zeros of ones
u = any(s>'~');                                   % 1 indicates '¢'; 0 indicates '~'
[~u u]*bin2dec({t(1,t(2,:)==49) t(:)'})           % compute both results and display
                                                  % that indicated by u

उदाहरण:

>> f('234 ¢ 4321')
ans =
    16841865

>> f('2345 ~ 7245')
ans =
    37

Answer 6

आर, 145 बाइट्स

s=scan(,"");a=as.double(c(s[1],s[3]));i=intToBits;cat(packBits(if(s[2]=="~")c(i(a[1])[i(a[2])>0],i(0))[1:32] else c(rbind(i(a[2]),i(a[1]))),"i"))

असंगठित + स्पष्टीकरण:

# Read a string from STDIN and split it on spaces
s <- scan(, "")

# Convert the operands to numeric
a <- as.double(c(s[1], s[3]))

o <- if (s[2] == "~") {
    # Get the bits of the first operand corresponding to ones in
    # the second, right pad with zeros, and truncate to 32 bits
    c(intToBits(a[1])[intToBits(a[2]) == 1], intToBits(0))[1:32]
} else {
    # Interleave the arrays of bits of the operands
    c(rbind(intToBits(a[2]), intToBits(a[1])))
}

# Make an integer from the raw bits and print  it to STDOUT
cat(packBits(o, "integer"))

Answer 7

पायथन 3, 174 166 148 126

बहुत सीधा, स्ट्रिंग ऑपरेशन, फिर पूर्णांक में रूपांतरण।

उन संख्याओं तक सीमित जो बाइनरी में 99 अंक (अधिकतम 2 ^ 99-1 = 633825300114114700748351602687) हैं।

धन्यवाद, Sp3000 और Vioz!

a,o,b=input().split()
print(int(''.join([(i+j,i[:j>'0'])[o>'~']for i,j in zip(*[bin(int(j))[2:].zfill(99)for j in(a,b)])]),2))

या 165 वर्ण, बिना सीमा के:

a,o,b=input().split()
a,b=[bin(int(j))[2:]for j in(a,b)]
print(int(''.join([(i if j=='1'else'')if o=='~'else i+j for i,j in zip(a.zfill(len(b)),b.zfill(len(a)))]),2))

Ungolfed:

a, op, b = input().split()
a, b = [bin(int(j))[2:] for j in(a,b)] #convert to int (base 10), then to binary, remove leading '0b'
m = max(len(a), len(b))
a = a.zfill(m) #fill with leading zeroes
b = b.zfill(m)
if op == '~':
    ret = [i if j=='1' else'' for i, j in zip(a, b)]
else:
    ret = [i + j for i, j in zip(a, b)]
ret = ''.join(ret) #convert to string
ret = int(ret, 2) #convert to integer from base 2
print(ret)

Comments

आप zfillrjust

— जीरो के

इनपुट 16 बिट पर अधिकतम, और 32 बिट पर आउटपुट। 99 बिट्स पर्याप्त से अधिक है।

— isaacg

मुझे पता है, लेकिन चूंकि takes 99 ’में there's 16’ के रूप में अधिक वर्ण हैं, इसलिए इसे सीमित करने का कोई लाभ नहीं है।

— तुरंग ऊल

कुछ और: 1) आपको बचाने की ज़रूरत नहीं है a,b, बस इसे zipएक *फुहार के साथ डालें , 2) (i if j=='1'else'') -> i[:j>'0']3) आप इस टिप का उपयोग दूसरे पर बचाने के लिए कर सकते हैंif/else

— Sp3000

मेरा समाधान आपके बहुत करीब होने के कारण समाप्त हो गया, इसलिए यहाँ पर मैं आपका (126 बाइट्स) प्राप्त कर सकता हूँ।

— केडे

Answer 8

पायथ, 43 बाइट्स

मुझे लगता है कि इसहाक के सवाल पर इस तरह के एक लंबे अजगर जवाब को पोस्ट करने में नर्वस महसूस होता है ...: ओ.पी.

J.(Kczd1Am.BvdKiu?qJ\~u+G?qeH\1hHk+VGHk.iGH2

explaination:

                                               Implicit: z=input(), k='', d=' '
   Kczd                                        Split z on spaces, store in K
J.(    1                                       Remove centre element from K, store in J
         m    K                                For each d in K
          .Bvd                                 Evaluate as int, convert to binary string
        A                                      Store pair in G and H
                                               ~ processing:
                                 +VGH          Create vectorised pairs ([101, 110] -> [11, 01, 10])
                     u               k         Reduce this series, starting with empty string
                        ?qeH\1                 If 2nd digit == 1...
                              hHk              ... take the 1st digit, otherwise take ''
                      +G                       Concatenate
                                      .iGH     ¢ processing: interleave G with H
                ?qJ\~                          If J == ~, take ~ processing, otherwise take ¢
               i                          2    Convert from binary to decimal

Comments

मुझे आपकी प्रोफ़ाइल तस्वीर अच्छी लगती है! :)

— kirbyfan64sos

@ kirbyfan64sos ब्लू किर्बी सर्वश्रेष्ठ किर्बी है: ओ)

— सोक

Answer 9

सी, 127 123 बाइट्स + 5 जुर्माना = 128

scanfयूनिकोड प्रतीक को एक से अधिक वर्णों के रूप में गिना जाता है जो चीजों को बहुत जटिल करता है, इसलिए मैं उपयोग करने के लिए 5-बाइट जुर्माना लगा रहा हूं $।

a,b,q,x,i;main(){scanf("%d %c %d",&a,&q,&b);for(i=65536;i/=2;)q%7?x=x*4|a/i*2&2|b/i&1:b/i&1&&(x=x*2|a/i&1);printf("%u",x);}

मूल संस्करण से बदलाव इस प्रकार हैं:

$ या ~ के लिए परीक्षण से संशोधित किया गया q&2है q%7। यह सही / गलत मूल्यों को उलट देता है, जिससे $ ऑपरेटर के लिए कोड को जाने की अनुमति मिलती है, :जिसका अर्थ है कि कोष्ठक का एक सेट समाप्त हो सकता है।

-यह iलूप अब 2 की शक्तियों में गिना जाता है जो लंबा है, लेकिन कुछ कोष्ठकों >>द्वारा प्रतिस्थापित करने की अनुमति देता है /और बचाता है।

मूल संस्करण 127 बाइट्स

a,b,q,x,i;
main(){
  scanf("%d %c %d",&a,&q,&b);
  for(i=16;i--;)
    q&2?
      b>>i&1&&(x=x*2|a>>i&1):    // ~ operator. && used as conditional: code after it is executed only if code before returns truthy.
      (x=x*4|(a>>i&1)*2|b>>i&1); // $ operator
  printf("%u",x);
}

मैं दो छोरों के उपरि से बचने के लिए अंदर की स्थिति के साथ एक ही लूप के साथ गया था। दोनों ही मामलों में मैं ऑपरेंड्स के बिट्स को 1 बिट तक राइट करता हूं, और सबसे महत्वपूर्ण से कम से कम महत्वपूर्ण बिट तक परिणाम का निर्माण करता हूं, जैसा कि मैं जाता हूं परिणाम (2 या 4 से गुणा करके) लेफ्टशंटिंग करता हूं।

Comments

मैंने आपके लिए इसे गॉल्फ़ किया: मुख्य (a, b, q, x, i) {scanf ("% d% c% d", & a, & q, & b); के लिए (i = 16; i -?) Q & 2; ख >> मैं और 1 && (एक्स = एक्स * 2 | एक >> मैं और 1) :( एक्स = एक्स * 4 | (क >> मैं और 1) * 2 | ख >> मैं और 1); printf ( "% u", एक्स);} मैंने >> i & 1 भागों को दूर करने की कोशिश की, लेकिन इसे करने के लिए लागत प्रभावी तरीका नहीं मिल सका। मैं मुख्य में परिवर्तनशील परिभाषाएँ डालकर 1 वर्ण को बचाने में सक्षम था। नोट: अप्राप्त

— लाम्बेबेटा

@LamdaBeta धन्यवाद, मुझे >> i & 1 के लिए मैक्रो नहीं मिला, लेकिन मैं इसे एक और तरीके से प्रबंधित करने में कामयाब रहा। मेरी मशीन पर भ्रष्ट होने के mainकारणों के तर्क के रूप में चर को रखना q, जो अजीब है। मुझे उम्मीद है कि असली समस्या साथ है scanf, लेकिन इस वजह से मैंने उन्हें सामान्य घोषणाओं के रूप में छोड़ दिया है।

— लेवल रिवर सेंट

मैंने ऐसा नहीं सोचा था। आप सही हैं, क्ष भ्रष्ट हो जाएगा। कारण यह है कि जब हम सीखते हैं कि मुख्य दो तर्क लेता है, कमांड-लाइन तर्कों की गिनती और तर्कों की एक सरणी, ज्यादातर सिस्टम वास्तव में एक तीसरा तर्क प्रदान करते हैं (आमतौर पर चार * envp [] कहा जाता है) जो पर्यावरण को कोड का वर्णन करता है में चलाया जाता है (ईजी: पर्यावरण चर तक पहुंच प्रदान करना)। इस प्रकार मुख्य में तीसरा मान भी सिस्टम द्वारा एक मान सौंपा जा सकता है, स्कैनफ इस समय निर्दोष है।

— लैम्ब्डाबेटा

@steveill मुझे लगता है कि आप 5 बाइट का जुर्माना भी हटा सकते हैं। मैंने सिर्फ आपके कोड का परीक्षण किया (155 बनाने के लिए ALT + 155 का उपयोग करके) और यह ठीक काम करता है। :)

— लैम्ब्डाबेटा

@LambdaBeta वास्तव में प्रयोग से पता चलता है कि यह दोनों का संयोजन है। सामान्य घोषणा के qसाथ शून्य होने की गारंटी दी गई है, लेकिन घोषणा के साथ फ़ंक्शन पैरामीटर के रूप qमें 32-बिट कचरा शामिल है। अगर मुझे कोई मान दिया जाए तो यह समस्या नहीं होगी q, लेकिन केवल कचरे के कम से कम 8 बिट्स को अधिलेखित करने के scanfसाथ "%c", अन्य 24 को अपरिभाषित छोड़ देगा। मैं एक और संकलक पर भाग्यशाली हो सकता है!

— लेवल रिवर सेंट

Answer 10

K5, 53 52 बाइट्स

{b/({,/x,'y};{x@&y})[*"~"=y][b\.x;(b:20#2)\.z]}." "\

53-बाइट संस्करण:

{b/({,/x,'y};{x@&y})[*"¢~"?y][b\.x;(b:20#2)\.z]}." "\

अभी भी थोड़ी और गोल्फिंग की जरूरत है।

Answer 11

CJam, 61 50 46 41 34 बाइट्स

धन्यवाद @ डेनिस एक 4 बाइट्स गोल्फ को इंगित करने के लिए।

rrc'~=:X;r]{i2bF0e[}/.{X{{;}|}&}2b

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

Comments

]{}/एक noop है।

— डेनिस

@ डेनिस धन्यवाद। मुझे शायद कुछ नींद मिलनी चाहिए ...

— एंड्रिया बियोनडो

Answer 12

हास्केल, 77

g=(`mod`2)
h=(`div`2)
0¢0=0
a¢b=g a+2*b¢h a
a?0=0
a?b=g a*g b+(1+g b)*h a?h b

इनपुट को फ़ंक्शंस / ऑपरेटर्स को इनपुट देकर ?और ¢कोड में परिभाषित किया जाता है (Haskell ~तकनीकी कारणों से ऑपरेटर को परिभाषित नहीं कर सकता है)।

मूल रूप से पुराने पुनरावर्ती दृष्टिकोण का काम करता है।

Answer 13

जे, 173

f=:|."1@(>@(|.&.>)@(#:@{:;#:@{.))
m=:2&#.@:,@:|:@:|.@:f
s=:2&#.@#/@:f
a=:{&a.@-.
(1!:2)&2(s@".@:a&126)^:(126 e.i)((m@".@:a&194 162)^:(1 e.194 162 E.i)i=._1}.(a.i.((1!:1)3)))

इनपुट की एक पंक्ति की अपेक्षा करता है

EOF के साथ नई लाइन के बाद इनपुट समाप्त होने की उम्मीद है

Answer 14

जावास्क्रिप्ट ईएस 6 (3 तर्क) 141 138 136 121 119 बाइट्स

b=x=>(65536|x).toString`2`
f=(x,o,y)=>+eval(`'0b'+(b(y)+b(x)).replace(/^1|${o=='~'?1:'(.)'}(?=.{16}(.)())|./g,'$2$1')`)

परीक्षा:

;[f(234,'¢',4321),f(2345,'~',7245)]=="16841865,37"

जावास्क्रिप्ट ईएस 6 (1 तर्क) 135 133 बाइट्स

b=x=>(65536|x).toString`2`
f=s=>([x,o,y]=s.split` `)|eval(`'0b'+(b(y)+b(x)).replace(/^1|${o=='~'?1:'(.)'}(?=.{16}(.)())|./g,'$2$1')`)

परीक्षा:

;[f('234 ¢ 4321'),f('2345 ~ 7245')]=="16841865,37"

पुनश्च: नई लाइन को 1 बाइट के रूप में गिना जाता है क्योंकि इसे प्रतिस्थापित किया जा सकता है ;।

Comments

0x10000 == 65536 (2 वर्णों को

— बचाएं

@ edc65, मैंने जवाब अपडेट कर दिया है।

— 21 अक्टूबर को Qwertiy

65536 | x से बचने के लिए ~~

— edc65

केवल दूसरे संस्करण की अनुमति है - इनपुट अंतरिक्ष सीमांकित स्ट्रिंग के रूप में होना चाहिए।

— isaacg

@ आइसाकग, ठीक है। लेकिन मैं ऐतिहासिक कारणों से पहले को हटाना नहीं चाहता।

— Qwertiy

Answer 15

पायथन 3, 157 बाइट्स

a,x,y=input().split()
i=int
b=bin
print(i(''.join(([c for c,d in zip(b(i(a)),b(i(y)))if d=='1'],[c+d for c,d in zip(b(i(a))[2:],b(i(y))[2:])])['¢'==x]),2))

पूर्ण और व्याख्यात्मक संस्करण मेरे पास्टबिन पर पाया जा सकता है ।

Comments

आप '== ’ऑपरेटर के आसपास के रिक्त स्थान हटाकर, and अगर’ से पहले और स्थितिगत तर्क के रूप में' आधार ’पास करके कुछ चार्ट बना सकते हैं।

— त्रंग ऊल

धन्यवाद, कि और कुछ अन्य लोगों ने १५ वर्ण बचाए हैं! लेकिन रिटर्न का प्रारूपण करने का दोहरा तरीका अभी भी बहुत कुछ है।

— ओलिवर फ्रेडरिक

इसके अलावा, क्या आप इंडेंट प्रति 4 स्थान का उपयोग करते हैं? एक (या टैब) पर्याप्त है।

— ट्रांग ओउल

@ बियोवुल्फ़ जब तक अन्यथा निर्दिष्ट न हो, आप एक पूर्ण कार्यक्रम या एक फ़ंक्शन सबमिट कर सकते हैं। आम तौर पर, जो छोटा होता है वह इस बात पर निर्भर करेगा कि आपकी भाषा चुनौती के लिए विशिष्ट इनपुट को पार करती है (रूबी आश्चर्यजनक रूप से उदाहरण के लिए स्टड से संख्याओं के साथ अनाड़ी है)। आपके पास आउटपुट के दो संभावित तरीके भी हैं: स्टडआउट या वापसी मूल्य, जो दोनों पर लागू होता है (हालांकि कार्यक्रमों से वापसी मूल्य दुर्लभ हैं।)

— लेवल रिवर सेंट

आप केवल eएक बार उपयोग करने के लिए दिखाई देते हैं , क्या आप इसे केवल इनलाइन नहीं कर सकते?

— केविन ब्राउन

Answer 16

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

f=IntegerDigits[#,2,16]&;
g=#~FromDigits~2&;
¢=g[f@#~Riffle~f@#2]&;
s=g@Cases[Thread@{f@#,f@#2},{x_,1}->x]&;
ToExpression@StringReplace[#,{" "->"~","~"->"s"}]&

इनपुट के रूप में स्ट्रिंग लेने वाले एक अनाम फ़ंक्शन का मूल्यांकन करता है। स्पष्टता के लिए लाइन ब्रेक जोड़े गए।

fऔर gआधार से / में परिवर्तित करें 2. Riffleबिल्कुल वही करता है जिसे इंटरलेव माना जाता है। मैं उपयोग करना चाहता था Selectके लिए चयन लेकिन Casesबेहतर दुर्भाग्य है। आखिरी पंक्ति थोड़ी सी चालाकी है; रिक्त स्थान को बदल दिया जाता है, ~जो कि मैथमेटिका के इन्फिक्स ऑपरेटर का है, फिर स्ट्रिंग का विस्तार है।