स्थान अंकगणित (लैटिन अंकगणितीय लोकलिस) एडिटिव (नॉन-पोजिशनल) बाइनरी अंक प्रणाली है, जिसे जॉन नेपियर ने अपने ग्रंथ रैडोलॉजी (1617) में प्रतीकात्मक तकनीक के रूप में प्रतीकात्मक रूप से और शतरंज की तरह ग्रिड पर दोनों में खोजा था।

क्या?

स्थान अंक वर्णमाला के अक्षरों का उपयोग करके संख्या लिखने का एक तरीका है।

बाइनरी नोटेशन को अभी तक मानकीकृत नहीं किया गया था, इसलिए नेपियर ने बाइनरी संख्याओं का प्रतिनिधित्व करने के लिए स्थान अंक का उपयोग किया। नेपियर की प्रणाली संख्याओं का प्रतिनिधित्व करने के लिए साइन-वैल्यू नोटेशन का उपयोग करती है; यह दो की क्रमिक शक्तियों का प्रतिनिधित्व करने के लिए अंग्रेजी वर्णमाला के क्रमिक अक्षरों का उपयोग करता है: a = 2 ^ 0 = 1, b = 2 ^ 1 = 2, c = 2 ^ 2 = 4, d = 2 ^ 3 = 8, e = 2 ^ 4 = 16 और इतने पर।

एक उदाहरण

ab आधार 10 में = 1 + 2 = 3

aabb आधार 10 में = 1 + 1 + 2 + 2 = 6

ध्यान दें कि पत्र के किसी भी 2 उदाहरणों को उच्चतर द्वारा प्रतिस्थापित करके aabbछोटा किया जा सकता है bc।

इसके अलावा

आप बस दो संख्याओं को संक्षिप्त करें और सरल करें।

acd+ bde= acdbde= abcdde= acebe= abcf= 39आधार १० में

घटाव

घटाव के दोनों हिस्सों में समान रूप से दिखने वाले सभी अंकों को हटा दें। विस्तार करना (परिवर्तित bकरना aa) आवश्यक हो सकता है

abde- ad= be= आधार १० में १ base

गुणन

यह थोड़ा कठिन है।

हम कहते हैं कि हम acd(13) गुणा def(56) करना चाहते हैं। पहले आप acdलंबवत व्यवस्था करें:

a
c
d

फिर आप defपहले के बाद जोड़ें a:

a def
c
d

अब, c, वर्णमाला की तुलना में बाद में 2 स्थान है, इसलिए हम defबनाने के लिए वर्णमाला में 2 स्थान जोड़ते हैं fgh। इसे दूसरी पंक्ति में जोड़ा जाता है।

a def
c fgh
d

अंत में, d, c की तुलना में वर्णमाला में बाद में 1 स्थिति है, इसलिए हम fghबनाने के लिए वर्णमाला में 1 स्थान जोड़ते हैं ghi। इसे तीसरी पंक्ति में जोड़ा जाता है।

a def
c fgh
d ghi

फिर आप सही का योग लेते हैं: def+ fgh+ ghi= deffgghhi= deggghhi= deghhhi= deghii= = deghj(728)

गुणन का एक और उदाहरण

इनपुट:

bc * de

प्रथम:

b
c

फिर

b ef
c

फिर

b ef
c fg

ध्यान दें कि हमने efपहली पंक्ति में नीचे लिखा था। ऐसा इसलिए है क्योंकि इससे bcशुरू होता है b, और bवर्णमाला का दूसरा अक्षर है, इसलिए हमें de1 अक्षर से बदलाव करना होगा , इसलिए यह बन जाता है ef।

फिर

ef+fg

आउटपुट:

eh

विभाजन

यह इस चुनौती का हिस्सा नहीं है, क्योंकि यह बहुत जटिल हो सकता है।

आपकी वास्तविक चुनौती

आपका प्रोग्राम या फ़ंक्शन इनपुट को एक स्ट्रिंग के रूप में लेना चाहिए जो इस तरह दिखता है:

a + b

और आपको आउटपुट चाहिए:

ab

बेशक, अपने कार्यक्रम या समारोह ऑपरेटरों से किसी के साथ (अपनी भाषा की स्ट्रिंग या इनपुट सीमा तक) मनमाना लंबाई की संख्या का समर्थन करना चाहिए +, -या *। कुछ और उदाहरण:

इनपुट:

ab + bd

आउटपुट:

acd

इनपुट:

d - ab

आउटपुट:

ac

इनपुट:

ab * cd

आउटपुट:

cf

आउटपुट में अक्षरों का क्रम मायने नहीं रखता है, लेकिन आप हमेशा यह मान सकते हैं कि इनपुट में संख्याओं का क्रम आरोही होगा (पहले z)।
आप एक अनुगामी newline और एक अनुगामी newline के साथ आउटपुट के साथ इनपुट ले सकते हैं।
आप कर सकते हैं नहीं की एक सूची के रूप में इनपुट ले ab, *और bdके लिए ab * bd।
अंग्रेजी वर्णमाला का उपयोग किया जाता है ( abcdefghijklmnopqrstuvwxyz)
आपका आउटपुट सरल होना चाहिए ( aaअनुमति नहीं है, bआवश्यक है)
इनपुट सरलीकृत किया जाएगा ( b+ c, नहीं aa+ bbया aa+ aaaa)
आप से पहले एक स्थान और ऑपरेटर (आवश्यकता हो सकती है +, -या *), या आप कोई भी होने की आवश्यकता हो सकती है।
प्रति इनपुट केवल एक ऑपरेटर होगा।
आप मान सकते हैं कि आउटपुट और इनपुट कभी 2 ^ 27-1 ( abcdefghijklmnopqrstuvwxyz) से अधिक नहीं होंगे
यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम जवाब जीतता है!

— programmer5000
स्रोत

2

d is 2 positions later in the alphabet than cक्या यह राइट है? क्या यह नहीं होना चाहिए 1? That is added to the second row.एक ही वाक्य पर, यह नहीं होना चाहिए third?

— फेलिप नारदी बतिस्ता

1

@FelipeNardiBatista अंग्रेजी वर्णमाला का उपयोग यहां किया गया है, इसे संपादित किया गया है।

— प्रोग्रामर

@ programmer5000 अभी भी, bc*de==efghलेकिन efghहै 240नहीं144

— फेलिप Nardi बतिस्ता

1

bc*deहोना चाहिएeh

— फेलिप नारदी बतिस्ता

@ दादा प्रति इनपुट केवल एक ऑपरेटर होगा।

— प्रोग्रामर

3

जेली , 26 25 बाइट्स

i@€Øað’2*S;ḟ.Ḣ
ḲÇ€VBṚTịØa

ओपी द्वारा अनुमति के अनुसार इनपुट स्ट्रिंग में जेली के ऑपरेटरों ( ×बजाय *और _इसके बजाय -) का उपयोग करता है ।

(ऑपरेटरों के आसपास रिक्त स्थान की आवश्यकता होती है)

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

कैसे?

i@€Øað’2*S;ḟ.Ḣ - Link 1, transform from input sub-string to value or operator: sub-string
i@€            - 1st index of, for €ach (or 0 if not found) [reversed @rguments] in:
   Øa          -      lowercase alphabet (i.e. a->1, b->2, ..., non-alpha->0)
     ð         - dyadic chain separation i.e. f(result above, substring):
      ’        - decrement (i.e a->0, b->1, ..., non-alpha->-1)
       2*      - 2 raised to that power
         S     - sum
          ;    - concatenate with the substring
           ḟ   - filter out:
            .  -     0.5 (for an operator substring the evaluated 0.5 is removed)
             Ḣ - head (i.e. the evaluation for a location, and the operator otherwise)

ḲÇ€VBṚTịØa - Main link: string                        e.g. 'ab × cd'
Ḳ          - split on spaces                               [['a','b'],['×'],['c','d']]
 Ç€        - last link (1) as a monadic function for €ach  [3,'×',12]
   V       - evaluate as Jelly code                        36
    B      - convert to binary                             [1,0,0,1,0,0]
     Ṛ     - reverse                                       [0,0,1,0,0,1]
      T    - truthy indexes                                [3,6]
       ị   - index into:
        Øa -     lowercase alphabet                        ['c','f'] (i.e. "cf", which is implicitly printed when run as a full program)

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

7

मैथेमेटिका, 168 बाइट्स

FixedPoint[StringReplace[x_~~x_:>FromCharacterCode[c@x+1]],Table["a",ToExpression@StringReplace[#,x:LetterCharacter..:>ToString@Tr[2^((c=ToCharacterCode)@x-97)]]]<>""]&

मेरा प्रारंभिक समाधान (पोस्ट को स्पष्ट करने के लिए संपादित किया गया था कि आउटपुट को सरल किया जाना चाहिए) 64बाइट्स छोटा था :

Table["a",ToExpression@StringReplace[#,x:LetterCharacter..:>ToString@Tr[2^(ToCharacterCode@x-97)]]]<>""

यह सिर्फ काम करने के लिए उस समाधान को संशोधित करता है। यह संभवतः चुनौती में वर्णित तरीकों का उपयोग करने के लिए कम है, लेकिन मैं इसे वैसे भी रखना चाहता था।

स्पष्टीकरण:

वर्ण कोड अंकगणित द्वारा अपने संबंधित पूर्णांक के साथ अक्षरों के प्रत्येक क्रम को aप्रतिस्थापित करता है, फिर परिणामी स्ट्रिंग को एक अभिव्यक्ति में परिवर्तित करता है (जो स्वचालित रूप से एक पूर्णांक को सरल करेगा), फिर उस पूर्णांक के बराबर लंबाई के पात्रों की एक स्ट्रिंग पैदा करता है , और अंत में आसन्न समान को जोड़ता है एक निश्चित बिंदु तक पहुंचने तक अगले वर्ण कोड वाले वर्ण।

— ngenisis
स्रोत

2

ओह, कोई 1-चार् बिलिन नहीं है? आश्चर्य की बात!

— प्रोग्रामर

7

जावास्क्रिप्ट (ईएस 6), 136 134 133 बाइट्स

ल्यूक की बदौलत बचा 1 बाइट

s=>[...a='abcdefghijklmnopqrstuvwxyz'].filter((c,i)=>eval(s.replace(/\w+/g,s=>[...s].reduce((p,c)=>p|1<<a.search(c),0)))&1<<i).join``

परीक्षण के मामलों

कोड स्निपेट दिखाएं

let f =

s=>[...a='abcdefghijklmnopqrstuvwxyz'].filter((c,i)=>eval(s.replace(/\w+/g,s=>[...s].reduce((p,c)=>p|1<<a.search(c),0)))&1<<i).join``

console.log(f('ab + bd'));  // acd
console.log(f('d - ab'));   // ac
console.log(f('ab * cd'));  // cf

Expand snippet

— Arnauld
स्रोत

अच्छी तरह से किया! आप मुझे इसे हरा ...

— प्रोग्रामर

क्या यह दशमलव और पीठ में परिवर्तित होता है? ऐसा प्रतीत होता है।

— प्रोग्रामर

1

@ प्रोग्रामर 5000 वास्तव में हाँ। मुझे संदेह है कि कई उत्तर होंगे। (पाठ्यक्रम को छोड़कर, गणितज्ञ, जो शायद इसके लिए एक अंतर्निहित है। ^ ^)

— अरनौल्ड

ऐसा लगता है कि आपकी टिप्पणी एक लिंक याद कर रही थी। इसमें एक अंतर्निहित फॉट क्या है?

— प्रोग्रामर

@ प्रोग्रामर 5000 (वास्तव में, यह एक शब्द याद आ रहा था।)

— अरनौल्ड

5

पर्ल 5 , 95 बाइट्स

कोड + -pध्वज के 94 बाइट्स ।

s/\w/a x 2**(-97+ord$&)/ge;s/(.*)-\1|\+//;/\*/&&($_=$`x length$');1while s/(.)\1/chr 1+ord$1/e

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

यहां तीन चरण:
- s/\w/a x 2**(-97+ord$&)/ge;इनपुट को aकेवल एक स्ट्रिंग में परिवर्तित करता है ।
- s/(.*)-\1|+//;/*/&&($_=$`x length$')ऑपरेटर को निष्पादित करेगा (जो कि तार पर बहुत सरल है a): +संघनन है, -पहले भाग को हटाने का मतलब है aजैसे कि दूसरे भाग में हैं, और *पहले भाग की नकल करने का मतलब है जितनी बार aदूसरे में हैं। अंश।
- 1while s/(.)\1/chr 1+ord$1/eअक्षर में अगले अक्षर में लगातार एक ही अक्षर को फोल्ड करता है।

— बापू
स्रोत

एकमात्र उत्तर जो दशमलव में परिवर्तित नहीं होता है! अच्छी नौकरी!

— प्रोग्रामर

1

@ programmer5000 2 जवाबों में से, मुझे वह प्रभावशाली नहीं लगेगी!

— दादा

5

05AB1E , 29 बाइट्स

ð¡À¬U¦v0yvAyko+}}X.VbRvyiANèJ

इसे ऑनलाइन आज़माएं! या टेस्ट सूट के रूप में

व्याख्या

ð¡                             # split input on string
  À                            # rotate left
   ¬U¦                         # get the operator, store it in X and remove it from list
      v                        # for each side of the equation
       0                       # push 0 as an accumulator
        yv                     # for each letter in each side of the equation
          Ayk                  # get its index in the alphabet
             o                 # raise 2 to this power
              +                # add to the accumulator
               }}              # end loops
                 X.V           # apply the operator to the 2 numbers now on the stack
                    bR         # convert to binary and reverse
                      v        # for each binary digit
                       yi      # if it is true
                         ANè   # get the letter at that index in the alphabet
                            J  # join stack to a single string

— Emigna
स्रोत

5

C & x86 asm, 340 बाइट्स

-O0 के साथ संकलित करें

#define G getchar()
g(){int c,a=0;for(;islower(c=G);)a+=1<<(c-97);return a;}
main(){short o[]={[43]=0x4403,[45]=0x442b,[42]=0x6cf7};
mprotect((long)&&l&~4095,4096,7);
for(;;){int c,b=0,a=g();*(short*)&&l=o[G];G;g();asm("xchg %%eax,%0":"+m"(a));
l:asm("addl %1,%%eax":"=a"(c):"m"(a));
for(;a=c>>b;b++)if(a&=1)putchar(97+b);putchar(10);}}

व्याख्या

चूंकि C के पास नहीं है eval(), इसलिए मैंने इसके स्थान पर x86 निर्देशों की एक तालिका का उपयोग किया। मुझे ऐसे निर्देश चुनने थे जो सभी समान लंबाई के थे (या नोड्स के साथ गद्देदार), और जो समान प्रकार के src और गंतव्य की उम्मीद करते थे। विशेष रूप से झुंझलाहट यह थी कि MUL केवल रजिस्टरों को लिख सकता है, और 1-बाइट MUL opcodes केवल EAX को लिख सकता है। इसके अतिरिक्त, ऐसा कोई रजिस्टर-लेखन SUB निर्देश प्रतीत नहीं हुआ, जो मेमोरी से घटाया गया हो, इसके बजाय अन्य तरीके से, इसलिए XCHG।

संपादित करें

चूंकि यह टिप्पणियों में पूछा गया था, इसलिए एक अधिक पारंपरिक मूल्यांकन इस तरह दिखाई देगा:

#define G getchar()
#define return r
#define int i
g(){i c,a=0;for(;islower(c=G);)a+=1<<(c-97);r a;}
a(i x,i y){r x+y;}s(i x,i y){r x-y;}m(i x,i y){r x*y;}
main(){i(*o[])(i,i)={[43]=a,[45]=s,[42]=m};
for(;;){i c,b,a=g();b=G;G;g();c=o[b](a,g());
for(b=0;a=c>>b;b++)if(a&=1)putchar(97+b);putchar(10);}}

यह वास्तव में थोड़ा छोटा है, 301 वर्णों पर, कुछ कारणों से: 1. क्योंकि बहुत सारे कार्यों को करने की आवश्यकता है, प्रत्येक के ओवरहेड को कुछ प्रीप्रोसेसर नियमों से कटा जा सकता है। 2. आधुनिक लिनक्स स्टैक पर निष्पादन से बचाता है, इसलिए mprotect () इस बलिदान को 34 बाइट को अक्षम करने के लिए कहता है। 3. XCHG कॉल बहुत उप-इष्टतम है, जिसकी लागत 30 बाइट्स है। यदि उन चीजों के लिए नहीं, तो x86 कॉम्बो लगभग 10-20 बाइट्स से जीतेगा।

इसके अलावा gl में islower () कॉल में सुधार करके दोनों से 2 बाइट्स काट लें।

— डेव
स्रोत

मैं वास्तव में नहीं बता सकता कि यह कोड-आकार के संदर्भ में अधिक शास्त्रीय दृष्टिकोण की तुलना कैसे करेगा, लेकिन मैं वास्तव में आपके समाधान को पसंद करता हूं। +1

— अरनौलड

5

GNU sed + coreutils, 329 बाइट्स

हाँ, मुझे पता नहीं है कि मुझे क्या मिला है, लेकिन कम से कम मुझे पता है कि स्क्रिप्टिंग थोड़ा बेहतर है। ध्यान दें कि इस समाधान के लिए GNU sed के eविस्तार की आवश्यकता है , जो एक शेल कमांड चलाता है।

/\+/{s/\+//
b S}
/-/{:E
/a+-a+/{s/(a*)(a*)-\2/\1/
b S}
s/.*/echo &|tr b-z- A-Y-/
e
s/([A-Z])/\L\1\1/g
b E}
/\*/{h
:M
/^\*/{x
s/[^\n]*//
s/\n//g
b S}
s/(.).*\*(.*)/echo \2|tr a-z \1-za-z/
e
H
g
s/.(.*)/\1/
h
s/\n.*//
b M}
:S
s/^.*$/echo &|grep -o .|sort|tr -d '\n'/
e
:L
s/(.)\1/\u\1/g
/^[a-z]*$/ q
s/.*/echo &|tr A-Z b-za/;e
b L

मुझे लगता है कि ऑपरेटरों के आसपास रिक्त स्थान नहीं होंगे। मेरे टर्मिनल से:

$ sed -rf golf.sed <<< a+b
ab
$ sed -rf golf.sed <<< ab+bd
acd
$ sed -rf golf.sed <<< abc+b
ad
$ sed -rf golf.sed <<< d-ab
ca
$ sed -rf golf.sed <<< ab*cd
cf
$ sed -rf golf.sed <<< bc*de
eh
$ sed -rf golf.sed <<< acd*def
deghj

और, मैं से उन लोगों के लिए: टिप्पणी संस्करण!

#!/bin/sed -rf

/\+/ {
    s/\+//
    b simplify
}

/-/ {
    # expand pattern space; everything will now be 'a's
    :E
    /a+-a+/{
        # Remove doubled 'a's on either side of the dash. For example,
        # for input d-ab, space is now 'aaaa-aaa'; substitute this to 'a'
        s/(a*)(a*)-\2/\1/
        b simplify
    }
    # shift letters that aren't 'a' down and double them
    s/.*/echo &|tr b-z- A-Y-/;e
    s/([A-Z])/\L\1\1/g
    b E
}

/\*/ {
    # Hold space: line 1 is pattern, other lines are output
    h
    :M

    # if space starts with *, we've eaten entire arg0; sum and simplify
    /^\*/ {
        x
        s/[^\n]*//      # remove first line, which is our pattern
        s/\n//g         # remove newlines to add results together
        b simplify
    }

    # convert pattern into shifting command
    s/(.).*\*(.*)/echo \2|tr a-z \1-za-z/

    # execute it, append result to hold space
    e
    H

    # restore pattern, with leading char and all output lines removed
    g
    s/.(.*)/\1/
    h
    s/\n.*//

    b M
}

:simplify
# reorder all letters so all 'a's are before all 'b's are before all 'c's
# are before ... etc    
# See /programming/2373874
s/^.*$/echo &|grep -o .|sort|tr -d '\n'/
e

:L
# Replace repeated characters with themselves upper-cased, then translate
# upper-cased characters to what they should be.
s/(.)\1/\u\1/g
/^[a-z]*$/ q
s/.*/echo &|tr A-Z b-za/;e
b L

— charliegreen
स्रोत

Sed कोड के लिए +1 और PPCG में आपका स्वागत है! जब शुद्ध GNU sed (या किसी अन्य शुद्ध भाषा में) को हल नहीं किया जाता है तो यह सम्मेलन, उदाहरण के लिए "GNU sed + coreutils" जैसे सिस्टम कमांड का उपयोग करने वाले शीर्षक को जोड़ने के लिए है, भले ही आप विवरण में शेल कमांड का उल्लेख कर रहे हों। । यह अलग-अलग करने के लिए किया जाता है, विशेष रूप से शुद्ध जीएनयू sed उत्तरों से नेता-बोर्डों के साथ चुनौतियों में।

— शीशमारा

इसके अलावा, हर बार ध्वज 'च' को छोड़कर, किसी भी अन्य ध्वज को 1 बाइट के रूप में गिना जाना चाहिए। तो आपका स्कोर 329 है। आप उस विवरण का उल्लेख करना चाह सकते हैं। और पूरा करने के लिए, आप TIO की तरह एक ऑनलाइन sed दुभाषिया के लिए एक कड़ी जोड़ने के बारे में सोच सकते हैं ।

— शेषमारा

सभी बात करने के लिए और कोई कार्रवाई नहीं होने के लिए, यहाँ एक 43 बाइट्स कम है! आपके कोड का संस्करण (286 बाइट्स -r सहित), जो कि मैंने कमांडों को गोल करके पाया। मुझे यकीन है कि यह और भी छोटा हो सकता है।

— शेषमारा

आह, ठीक है, अच्छा पता है! इसके अलावा, अच्छा गोल्फ! हालांकि आप किस सेड के संस्करण का उपयोग कर रहे हैं? तुम्हारा काम TIO में होता है, लेकिन GNU sed 4.4 में मुझे बस मिल जाता हैsed: file golf.sed line 24: ":" lacks a label

— charliegreen

जीएनयू सेड में नामहीन लेबल एक प्रसिद्ध बग है, जो संस्करण 4.3 में तय किया गया था। लेकिन पीपीसीजी पर, आप बग के रूप में बग का उपयोग करके किसी भी सेड वैरिएंट और संस्करण के लिए प्रोग्राम लिख सकते हैं, अगर यह गोल्फ में मदद करता है। संस्करणों के बीच अंतर (4.2 बनाम 4.4) का उल्लेख करने के लिए बहुत छोटा है, लेकिन संस्करण (मानक POSIX sed बनाम विस्तारित GNU sed) को शीर्षक में निर्दिष्ट करने की आवश्यकता है, सिस्टम प्रोग्रामों के उल्लेख के साथ, यदि कोई हो।

— शेषमारा

4

PHP, 168

उत्खनन के उपयोग के साथ आउटपुट आरोही

[$a,$o,$b]=explode(" ",$argn);function d($s){for(;$i<strlen($s);)$n+=2**(ord($s[$i++])-97);return$n;}for(eval("\$k=d($a)$o d($b);");$i<26;)echo$k&2**$i++?chr(96+$i):"";

PHP, 185 बाइट्स

आउटपुट आरोही

[$a,$o,$b]=explode(" ",$argn);function d($s){for(;$i<strlen($s);)$n+=2**(ord($s[$i++])-97);return$n;}for(;$i<26;)echo(bc.[mul,add,0,sub][ord($o)-42])(d($a),d($b))&2**$i++?chr(96+$i):"";

ऑनलाइन संस्करण

विस्तारित

[$a,$o,$b]=explode(" ",$argn); # part the input into variables
function d($s){ # make decimal value
    for(;$i<strlen($s);)$n+=2**(ord($s[$i++])-97);
    return$n;
}
for(;$i<26;)
echo(bc.[mul,add,0,sub][ord($o)-42])(d($a),d($b))&2**$i++?chr(96+$i):""; # Bitwise Compare and Output

PHP, 201 बाइट्स

आउटपुट का निर्णय

[$a,$o,$b]=explode(" ",$argn);function d($s){for(;$i<strlen($s);)$n+=2**(ord($s[$i++])-97);return$n;}for($r=(bc.[mul,add,0,sub][ord($o)-42])(d($a),d($b));$r;$r-=2**$l)$t.=chr(97+$l=log($r,2)^0);echo$t;

ऑनलाइन संस्करण

विस्तारित

[$a,$o,$b]=explode(" ",$argn); # part the input into variables
function d($s){ # make decimal value
    for(;$i<strlen($s);)$n+=2**(ord($s[$i++])-97);
    return$n;
}
for(
$r=(bc.[mul,add,0,sub][ord($o)-42])(d($a),d($b)) # result of the operation
;$r;
$r-=2**$l) # subtract the letter value 
$t.=chr(97+$l=log($r,2)^0); # find greatest letter
echo$t; # Output

— जार्ग हुल्सरमन
स्रोत

4

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

i=lambda a:str(sum(1<<ord(i)-97for i in a))
def f(a):
 a,b,c=a.split();m=eval(i(a)+b+i(c));r=''
 while m:
  t=0
  while m>=2**t*2:t+=1
  r+=chr(97+t);m-=2**t
 return r

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

9 बाइट्स को बचाया: टटलमैन को धन्यवाद

— officialaimm
स्रोत

1

जब तक मैं गलत कर रहा हूँ, आप की जगह दो बाइट्स बंद दाढ़ी कर सकते हैं m>=2**(t+1)के साथ m>=2**t*2की जगह है, और पाँच बाइट्स a=a.split();m=eval(i(a[0])+a[1]+i(a[2]))की तरह कुछ के साथ b,c,d=a.split();m=eval(i(b)+c+i(d))।

— टटलमैन

1

ओह, और दो बाइट्स के 2**(ord(i)-97)साथ बदलकर 1<<ord(i)-97।

— टटलमैन

1

मैं चकित हूं कि यह समाधान अन्य समाधानों की तुलना में कितना पठनीय है।

— ओले तागे

धन्यवाद :)। लेकिन मुझे लगता है कि इसकी वजह भी अजगर द्वारा इस्तेमाल की जाने वाली भाषा है। इंडेंटेशन बाइट की गिनती बढ़ाता है, हालांकि पठनीय है। ;)

— आधिकारिक

2

PHP, 130

for($d=a;$e=$argn[$i++];)$e!=' '?$d!=b?$$d+=1<<ord($e)-97:$b=$e:++$d;eval("for(;\$j++<27;)echo($a$b$c>>\$j-1)&1?chr(96+\$j):'';");

विस्तारित संस्करण:

for($d=a;$e=$argn[$i++];)       // for each char in the input
  $e!=' '?                      //   if space
    $d!=b?                      //     if not the operation
      $$d+=1<<ord($e)-97:       //       add 2^(char - 'a')
      $b=$e:                    //     else save operation
    ++$d;                       //   else increase "pointer"
eval("for(;\$j++<27;)           // for each bit in the output
        echo($a$b$c>>\$j-1)&1?  //   calulate the result and check the bit
          chr(96+\$j):          //     output corrosponding char
          '';                   //     output nothing
     ");

साथ चलाना php -R <code>।

— क्रिस्टोफ
स्रोत

1

AWK, 201 बाइट्स

BEGIN{RS="(.)"}n=index(V="abcdefghijklmnopqrstuvwxyz",RT){s+=2^--n}index("+-*",RT){a=s RT
s=0}END{RS="\n"
"(awk '$0="a s"'<<<1)"|getline v
for(j=26;j--;)if((s=v-2^j)>=0){v=s;c=substr(V,j+1,1)c}print c}

"(awk '$0="a s"'<<<1)"|getline vसबसे अच्छा तरीका है कि मैं एक evaluateमें करने के लिए आ सकता है AWK। मैं बस इसे कॉल करने के लिए थोड़ा "धोखा" दे सकता हूंAWK , क्योंकि मैं एक कमांड निष्पादित कर रहा हूं, लेकिन कम से कम कमांड भी है AWK:)

मुझे यकीन है कि मैं बाइट-काउंट को कम करने का कोई तरीका याद कर रहा हूं, लेकिन मुझे यकीन है कि यह नहीं देख सकता।

उपयोग काफी मानक है, उदाहरण के लिए कोड डालें FILEऔर करें:

awk -f FILE <<< "bc + ab"

ध्यान दें कि रिक्त स्थान की आवश्यकता नहीं है और किसी भी गैर- op / गैर [az] वर्ण को चुपचाप नजरअंदाज कर दिया जाएगा। लूप को बदलकर "abcdefghijklmnopqrstuvwxyz" से अधिक संख्या के साथ काम करने के लिए बढ़ाया जा सकता है। विभाजन करने के लिए, बस /चरित्र को ऑपरेशन स्ट्रिंग में जोड़ें :)। इसके अलावा, अगर एक खाली लाइन प्रिंट होगा result <= 0।

— रॉबर्ट बेन्सन
स्रोत

चलो कुछ स्थान अंकगणित करते हैं!

क्या?

एक उदाहरण

इसके अलावा

घटाव

गुणन

गुणन का एक और उदाहरण

विभाजन

आपकी वास्तविक चुनौती

टिप्पणियाँ:

जेली , 26 25 बाइट्स

कैसे?

मैथेमेटिका, 168 बाइट्स

स्पष्टीकरण:

जावास्क्रिप्ट (ईएस 6), 136 134 133 बाइट्स

परीक्षण के मामलों

पर्ल 5 , 95 बाइट्स

05AB1E , 29 बाइट्स

C & x86 asm, 340 बाइट्स

GNU sed + coreutils, 329 बाइट्स

PHP, 168

PHP, 185 बाइट्स

PHP, 201 बाइट्स

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

PHP, 130

AWK, 201 बाइट्स