खैर यह अजीब है ... कोई प्रतीक्षा नहीं, वह भी!

Question

प्रस्तावना

इंटेगर हमेशा या तो विषम होते हैं । यहां तक ​​कि पूर्णांक दो से विभाज्य हैं, विषम पूर्णांक नहीं हैं।

जब आप दो पूर्णांक जोड़ते हैं, तो आप अनुमान लगा सकते हैं कि क्या परिणाम सम या विषम के आधार पर विषम होगा या नहीं:

• सम + इव = सम
• सम + विषम = विषम
• विषम + सम = विषम
• विषम + विषम = सम

इसी तरह, जब आप दो पूर्णांकों को गुणा करते हैं, तो आप अनुमान लगा सकते हैं कि क्या परिणाम और भी विषम होंगे या नहीं, यह इस आधार पर होगा कि क्या कारक भी आसान थे या नहीं:

• यहाँ तक कि * इवन = भी
• सम * विषम = सम
• विषम * इव = सम
• विषम * विषम = विषम

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

उदाहरण के लिए, हम विश्वास के साथ कह सकते हैं कि (68 + 99) * 37परिणाम एक विषम है क्योंकि एक सम विषम ( 68 + 99) एक विषम है, और वह विषम समय एक और विषम ( odd * 37) विषम देता है।

चुनौती

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

आपका कार्य अभिव्यक्ति को सरल करना, मुद्रण करना या वापस करना है eया इस oआधार पर कि क्या अभिव्यक्ति का परिणाम सम या विषम है।

आप मान सकते हैं कि इनपुट हमेशा मान्य उपसर्ग संकेतन में होगा। विशेष रूप से, प्रत्येक +और *हमेशा इसके बाद होने वाले दो संबंधित ऑपरेंड होंगे। ये ऑपरेशंस एकल eया o, या अन्य +या *अभिव्यक्ति हो सकते हैं जो बदले में ऑपरेंड होते हैं।

उदाहरण के लिए, इनपुट *+eooको सामान्य इन्फिक्स नोटेशन के रूप mul(add(e, o), o)में या पढ़ा जा सकता है । और पहली करने के लिए इसी ऑपरेंड हैं , और और पिछले करने के लिए इसी ऑपरेंड हैं ।(e + o) * oeo++eoo*

बस इसे स्पष्ट करने के लिए, यहां कुछ अमान्य इनपुट हैं जिनमें गलत उपसर्ग संकेतन है:

eo
ooe
o+e
ee*
+*oe
+e*o

आउटपुट में एक एकल अनुगामी न्यूलाइन ठीक है, लेकिन अन्यथा eसम या oविषम के लिए एक सादा वह सब है जो आउटपुट होना चाहिए।

बाइट्स में सबसे छोटा कोड जीतता है।

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

^{(खाली लाइनें केवल दृष्टिगत रूप से समान मामलों को अलग करने में मदद करने के लिए हैं।)}

e -> e
o -> o

+ee -> e
+eo -> o
+oe -> o
+oo -> e
*ee -> e
*eo -> e
*oe -> e
*oo -> o

+e+ee -> e
+e+eo -> o
+e+oe -> o
+e+oo -> e
+e*ee -> e
+e*eo -> e
+e*oe -> e
+e*oo -> o

+o+ee -> o
+o+eo -> e
+o+oe -> e
+o+oo -> o
+o*ee -> o
+o*eo -> o
+o*oe -> o
+o*oo -> e

*e+ee -> e
*e+eo -> e
*e+oe -> e
*e+oo -> e
*e*ee -> e
*e*eo -> e
*e*oe -> e
*e*oo -> e

*o+ee -> e
*o+eo -> o
*o+oe -> o
*o+oo -> e
*o*ee -> e
*o*eo -> e
*o*oe -> e
*o*oo -> o

++eee -> e
++eeo -> o
++eoe -> o
++eoo -> e
++oee -> o
++oeo -> e
++ooe -> e
++ooo -> o

+*eee -> e
+*eeo -> o
+*eoe -> e
+*eoo -> o
+*oee -> e
+*oeo -> o
+*ooe -> o
+*ooo -> e

*+eee -> e
*+eeo -> e
*+eoe -> e
*+eoo -> o
*+oee -> e
*+oeo -> o
*+ooe -> e
*+ooo -> e

**eee -> e
**eeo -> e
**eoe -> e
**eoo -> e
**oee -> e
**oeo -> e
**ooe -> e
**ooo -> o

+e+e+e+ee -> e
+o+o+o+oo -> o
*e*e*e*ee -> e
*o*o*o*oo -> o
+e+o+e+oe -> e
+o+e+o+eo -> o
*e*o*e*oe -> e
*o*e*o*eo -> e
+e*e+e*ee -> e
+o*o+o*oo -> o
*e+e*e+ee -> e
*o+o*o+oo -> o

+**++*+*eeoeeooee -> e
+**++*+***eooeoeooeoe -> e
+**+***+**++**+eooeoeeoeeoeooeo -> o

+e*o*e**eoe -> e
+*e+e+o+e**eeoe -> e
**o++*ee*++eoe*eo+eoo -> o

Comments

क्या हम इनपुट के रूप में e और o के बजाय 1 और 0 ले सकते हैं?

— घोस्ट_इन_थे_कोड १०

@ghosts_in_the_code नहीं, क्षमा करें।

— केल्विन के शौक

evalठीक उपयोग कर रहा है ?

— xnor

@ एक्सनोर श्योर। जो कुछ भी काम करता है।

— केल्विन के शौक

मुझे संदेह है कि मैं पहले से ही पोस्ट किए गए 13 बाइट्स को हरा करने के लिए इसका इस्तेमाल कर सकता हूं, लेकिन मुझे लगता है कि इसके अलावा एक विशेष या गुणा से मेल खाता है या एक सरल।

— WGroleau

Answer 1

सीजाम, 18 17 13 बाइट्स

4 बाइट बचाने के लिए aditsu का धन्यवाद।

qW:O%eu~"eo"=

यहां परीक्षण सूट का प्रयास करें। (परीक्षण सूट पर्मलिंक के लिए बहुत लंबा है। बस उन्हें चुनौती की युक्ति से कॉपी करें।)

व्याख्या

q     e# Read the input.
W:O   e# Push a -1 and store it in variable O.
%     e# Use the -1 to reverse the string, because CJam's stack-based nature and the
      e# commutativity of the operators means we can evaluate the code in postfix notation.
eu    e# Convert the string to upper case, turning 'e' into 'E' (a variable with even value
      e# 14) and 'o' into 'O' (which we've stored the odd value -1 in).
~     e# Evaluate the string as CJam code, leaving the result on the stack.
"eo"= e# Use the result as an index into the string "eo". CJam's indexing is cyclic so it
      e# automatically takes inputs modulo 2. Negative indices also work as expected.

Answer 2

पायथ, 16 14 बाइट्स

@"eo".vjdXzGU9

Pyth स्वयं एक स्ट्रिंग का मूल्यांकन कर सकता है, जो Pyth सिंटैक्स में है। इसलिए मैं प्रतिस्थापित करता हूं eऔर उसके oसाथ 4और 5। फिर मूल्यांकन मुझे एक समान या विषम संख्या देगा, और मैं आसानी से परिणाम प्रिंट कर सकता हूं।

इसे ऑनलाइन आज़माएँ: प्रदर्शन या टेस्ट सूट

स्पष्टीकरण:

@"eo".vjdXzGU9   implicit: z = input string
         XzGU9   replace "e" in z with 4 and "o" with 5
       jd        put a space between each char
     .v          evaluate it (Pyth style)
@"eo"            and print "e" or "o"

प्रतिस्थापित करने के लिए अतिरिक्त स्पष्टीकरण। Gएक वर्णमाला के साथ आरंभिक चर है abc...xyz। U9सूची है [0, 1, ..., 8]। XzGU9सूची के मूल्यों के साथ वर्णमाला के अक्षरों को बदलता है। तो aके साथ बदल जाता है 0, bके साथ 1, ..., eसाथ 4, ..., iसाथ 8, jसाथ 0, ..., और oसाथ 5। इसलिए मुझे eएक सम संख्या और oएक विषम संख्या के साथ बदल दिया जाता है । अन्य सभी प्रतिस्थापनों का कोई प्रभाव नहीं पड़ता है।

Comments

आप अभिव्यक्ति को उलट क्यों रहे हैं? इसके अलावा, आपको परिणाम modulo 2 लेने की आवश्यकता नहीं है, या इंडेक्सिंग चारों ओर लपेट रहा है?

— xnor

@ एक स्ट्रिंग में एक तत्व तक पहुँचने के लिए मोडुलो रैपिंग किया जाता है। तो modulo 2 के लिए कोई ज़रूरत नहीं है

— Jakube

@ एक्सनोर लेकिन रिवर्स चीज के लिए धन्यवाद। बेशक यह आवश्यक नहीं है। (मैं आज एक

— लिटिल

Answer 3

पर्ल, ५० ४५ ४० अक्षर

(39 वर्ण कोड + 1 वर्ण कमांड लाइन विकल्प।)

1while s/\+oe|\+eo|\*oo/o/||s/\W\w\w/e/

नमूना रन:

bash-4.3$ echo -n '**o++*ee*++eoe*eo+eoo' | perl -pe '1while s/\+oe|\+eo|\*oo/o/||s/\W\w\w/e/'
o

Comments

कैसे के बारे में while/../?

— प्रिमो

रवींद्र। मुझे बेवकूफ। वास्तव में अपने sedसंस्करण की कोशिश करते समय उस स्थिति का उपयोग किया ... धन्यवाद, @primo।

— मैनेटवर्क

या इससे भी बेहतर 1while s/\+oe...,। मुझे भी पूरा यकीन है कि [+*]इसे बदला जा सकता है \W।

— प्रिमो

धन्यवाद फिर से, @primo। मुझे लगता है कि मुझे एक बार एक ही समाधान पर ध्यान केंद्रित करना चाहिए। ( gemaमुझे पागल कर रहा है ...)

— manatwork

सैड के साथ एक ही दृष्टिकोण अब 2 बाइट्स छोटे!

— डिजिटल ट्रॉमा

Answer 4

रेटिना , 29 बाइट्स

(+`\*oo|\+(eo|oe)
o
\W\w\w
e

सुविधाजनक एक फ़ाइल संस्करण के लिए -sध्वज का उपयोग किया जाता है।

हम अजीब भाव (स्वैप *oo, +oe, +eoके लिए) oजब तक हम, तो करने के लिए शेष प्रतीक अक्षर अक्षर का भाव स्वैप कर सकते हैं e। हम इसे तब तक दोहराते हैं जब तक हम कर सकते हैं और अंतिम एक अक्षर हमारा आउटपुट है।

(यह समाधान मैनटवर्क के पर्ल उत्तर के समान है ।)

इसे ऑनलाइन आज़माएं! (डेनिस द्वारा)

Answer 5

अजगर 2, 90

def f(s):i=iter(s);a=next(i);return(a>'a')*a or'oe'[f(i)==f(i)if'*'<a else'e'in f(i)+f(i)]

iterसमारोह एक फीफो कतार जो याद है कैसे स्ट्रिंग के ज्यादा के कॉल भर में पार्स किया गया है में इनपुट स्ट्रिंग बनाने के लिए एक अच्छा तरीका है f। यह बेकार है, इसलिए इसे तब कॉल करना हानिरहित है जब इनपुट पहले से ही एक स्ट्रिंगर के बजाय एक पुनरावृत्त हो। उत्तर की शुरुआत का अनुगामी आधा or'oe'... ऐसा लगता है जैसे यह गोल्फ होना चाहिए, लेकिन मुझे कुछ भी नहीं मिला।

-1 Sp3000 के लिए धन्यवाद।

Comments

महान समाधान! iterवास्तव में मेरे दिमाग का उपयोग कर पुनरावर्ती कार्य करता है।

— xnor

यहाँ के साथ सीधे अंकगणित की गणना करने का एक तरीका है eval:def f(s,e=0,o=1):i=iter(s);a=next(i);return'eo'[eval(a*(a>'a')or f(i)+a+f(i))%2]

— 21

@xnor आप उत्तर के रूप में अच्छी तरह से पोस्ट कर सकते हैं। यह इस समाधान से बहुत अलग है।

— feersum

Answer 6

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

#//.s_:>s~StringReplace~{"+ee"|"+oo"|"*ee"|"*eo"|"*oe"->"e","+eo"|"+oe"|"*oo"->"o"}&

इसे कंप्रेस करने का तरीका खोज रहे हैं ...

Comments

//.से छोटा है FixedPoint।

— alephalpha

Answer 7

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

def f(s,e=0,o=1):i=iter(s);a=next(i);return(a>'a')*a or'eo'[eval(f(i)+a+f(i))%2]

यह फ़ेर्सम के बहुत ही चतुर उत्तर पर बनाया गया है जो iterपोलिश-संकेतन कार्यों को लागू करने के लिए उपयोग करता है । नए विचार का उपयोग evalअभिव्यक्तियों के मूल्यांकन के लिए किया जाता है +और इसके *साथ eval(f(i)+a+f(i)), जहां ऑपरेटर aको पुनरावर्ती परिणामों के बीच इनफ़िक्स रखा जाता है। Eval e=0,o=1वैकल्पिक फ़ंक्शन तर्क में बाइंडिंग का उपयोग करता है। आउटपुट को फिर mod 2 लिया जाता है।

Comments

यह अजगर में भी काम करता है 3. वैसे, eval को "e = 0, o = 1" बाइंडिंग की आवश्यकता कैसे होती है?

— करहल

@Khell यह भावों का मूल्यांकन करता है e+o, इसलिए इसे संख्याओं को संदर्भित करने के लिए चर की आवश्यकता होती है।

— 21

Answer 8

सी, 79 बाइट्स

सीधी पुनरावृत्ति। कुछ पर निर्भर (संयोग?) चार अनुमत इनपुट वर्णों के बिटवाइस गुण।

f(){int c=getchar();return c&4?c:c&1?f()^f()^'e':f()&f();}main(){putchar(f());}

Answer 9

शेल + जीएनयू उपयोगिताओं, 33

dc -eFo`rev|tr oe OK`2%p|tr 10 oe

इनपुट STDIN से लिया गया है।

यह इस मामले में इनपुट को उलटने और स्टैक-आधारित कैलकुलेटर के साथ मूल्यांकन करने की समान चाल करता है dc। हम बदल सकते eहैं और oसाथ 0और 1है, लेकिन फिर रिक्त स्थान गलत संख्या में अंकों की लालची पार्स को रोकने के लिए सम्मिलित करने के लिए की आवश्यकता होगी।

इसके बजाय इसके eसाथ प्रतिस्थापित किया जाता है Kजो dcस्टैक के लिए वर्तमान परिशुद्धता को पुश करने के लिए कमांड है, जो कि डिफ़ॉल्ट रूप से 0. है और oइसके साथ बदल दिया गया है Oजो dcस्टैक के लिए वर्तमान आउटपुट बेस को पुश करने के लिए कमांड है। यह अजीब होने की आवश्यकता है, इसलिए हम इसे Foडीसी में कुछ और करने से पहले 15 के साथ सेट करते हैं ।

फिर यह केवल मॉड 2 और प्रिंटिंग लेने की बात है 2%p। केवल संभावित मान अभी 0और हैं 1, इसलिए यह मायने नहीं रखता कि आउटपुट बेस 15. है। फिर trवापस oया में अनुवाद करता है e।

---

मुझे यह पसंद है कि यदि आप अपनी आँखें निचोड़ते हैं, तो यह स्रोत लगभग दिखता है dc Forever OK।

Answer 10

गंभीरता से , 24 बाइट्स

,R'2'e(Æ'1'o(Æ£ƒ'e'o2(%I

अधिक कुशल स्टैक हेरफेर शायद यह कम कर सकता है, लेकिन meh, मैं इसके साथ खुश हूं।

इनपुट को एक स्ट्रिंग की तरह लेता है, जैसे "+*oee"

इसे ऑनलाइन आज़माएं (इनपुट मैन्युअल रूप से दर्ज किया जाना चाहिए)

स्पष्टीकरण:

,R        get input and reverse it
'2'e(Æ    replace all "e"s with "2"s
'1'o(Æ    replace all "o"s with "1"s
£ƒ        cast as function and call
'e'o2(%I  push "e" if result is even, else "o"

Answer 11

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

पुनरावर्ती वंश पार्सिंग और बूलियन बीजगणित का उपयोग करना।

def f
gets(1)==?+?f^f : ~/\*/?f&f : $_==?o
end
puts f ? ?o:?e

फ़ंक्शन एक बार में स्टड से एक वर्ण पढ़ता है। यदि यह एक +या एक पढ़ता है *, तो यह विषम या सम्‍मिलित करने के लिए दो बार कॉल करता है। फ़ंक्शन trueविषम और के falseलिए लौटता है even। ^ XOR और & और ऑपरेटरों क्रमशः अलावा और गुणा अभिव्यक्ति की "विचित्रता" निर्धारित करने के लिए किया जाता है।

यहाँ एक ungolfed संस्करण है:

def f
  x = gets(1)
  case x
  when '+'
    f ^ f
  when '*'
    f & f
  else
    x == 'o'
  end
end

puts f ? 'o' : 'e'

_{प्रारंभिक संस्करण में बग को इंगित करने के लिए धन्यवाद @ शीश।}

Comments

यह काम नहीं करता है, +eeदेता है o। मुझे यह विचार पसंद है

— शेल्वैक्यू

की जगह f^fके साथ !f^fऔर f&fसाथ f|fहै और यह काम करता है। परीक्षण मामलों को चलाने के लिए कार्यक्रम: pastebin.com/ufXfd1vc

— शेल्वैक्यू

धन्यवाद, अच्छी पकड़! लगता है मैंने खुद को वहाँ थोड़ा भ्रमित कर लिया। अच्छा टेस्ट सूट भी! टेस्ट-संचालित होने का रास्ता है, वह भी जब गोल्फिंग :)

— daniero

@ शील अहा ..! मैं वापस बदल गया f^fऔर f&fफ़्लिप किया $_==?eऔर ?e:?oइसके बजाय :)

— daniero

वाह, हर दिन कुछ नया सीखें ... ruby-doc.org/core/Regexp.html#method-i-7E

— Shelvacu

Answer 12

मिंकोलंग 0.14 , 40 बाइट्स

मैंने एक चतुर विकास विधि करने की कोशिश की, लेकिन यह पता चला कि मूल स्थान के बाहर कोडबॉक्स में जोड़ा गया कोई भी मान प्रोग्राम काउंटर तक कभी नहीं पहुंचेगा। इसलिए मैंने एक कम चतुर विकसित तरीका अपनाया। : पी

$o"eo+*"r0I4-[4g1Z2*1F]l*"e"+O.
0f1f+f*f

इसे यहाँ आज़माएँ।

व्याख्या

$o                                Read in whole input as characters
  "eo+*"                          Push these characters onto the stack (in reverse order)
        r                         Reverse the stack
         I4-                      Push the length of the stack - 4
            [                     For loop; pop n and repeat that many times
             4g                   Get the item at the fourth index and put it on top
               1Z                 Pops n and pushes first index of n in stack
                 2*               Multiply by 2
                   1F             Gosub; goes to codebox(2n,1) to be returned to
                     ]            Close for loop
                      l*          Multiply by 10
                        "e"+      Add 101 ("o" is 111)
                            O.    Output as character and stop.
0f1f+f*f                          Does the appropriate operation then returns to F

Comments

वू हू! अच्छा राजभाषा 'शैल एक (अर्द्ध) गोल्फ भाषा धड़कता है; --P

— डिजिटल आघात

Answer 13

जावास्क्रिप्ट, 110 106 94 बाइट्स

while(i.length>2)i=i.replace(/([+*][eo]{2})/,(o,e)=>{return"+oe+eo*oo".indexOf(o)<0?"e":"o"});

निश्चित रूप से सबसे छोटा समाधान नहीं है, लेकिन संभवतः जावास्क्रिप्ट जैसी क्रिया भाषा में सबसे छोटा समाधान संभव है!

Comments

गैर-कैप्चरिंग समूहों का उपयोग प्रदर्शन के लिए अच्छा है लेकिन कोड आकार के लिए बुरा है। बेहतर वे हटा दें ?:।

— 15 दिसबंर को 15

सहमत ... और इसलिए संशोधित।

— अरकेन

अब एक और रूप ले लिया। आपके कोड को थोड़ा और कम किया जा सकता है while(i.length>2)i=i.replace(/[+*][eo]{2}/,function(o){return"+oe+eo*oo".indexOf(o)>=0?"o":"e"})। या यदि आप ईसीएमएस्क्रिप्ट 6 के वसा तीर फ़ंक्शन में बदलते हैं, तो while(i.length>2)i=i.replace(/[+*][eo]{2}/,o=>"+oe+eo*oo".indexOf(o)>=0?"o":"e")। लेकिन दुर्भाग्य से आवश्यकता कार्यक्रम या फ़ंक्शन कहती है, जबकि आपका वर्तमान कोड एक स्निपेट है। इसे इनपुट और आउटपुट या तर्क और रिटर्न वैल्यू दोनों को संभालना चाहिए।

— मैनटवर्क

दुर्भाग्य से इस साइट पर मान्य होने के कारण, हम यह नहीं मान सकते कि एक चर पहले से मौजूद है। iजैसा आपने कहा था, आपको इसे एक कार्य करना होगा ।

— एलेक्स ए।

@Arain, आपको नियमित अभिव्यक्ति में एक समूह पर कब्जा करने की आवश्यकता नहीं है क्योंकि आप वैसे भी एक टुकड़े के रूप में पूरे मिलान किए गए प्रतिस्थापन का उपयोग करेंगे। उसी कारण से कॉलबैक के लिए पैरामीटर ई पास करने की आवश्यकता नहीं है।

— 5

Answer 14

ओ , 24 20 19 18 बाइट्स

i`2:e;1:o;~2%'o'e?

, इनपुट लेता है यह उलट जाता है, प्रदान करती है eके लिए 2 और oकरने के लिए 1 और पदों यह Tumblr के लिए हे कोड के रूप में यह मूल्यांकन करता है।

स्पष्टीकरण:

i` इनपुट प्राप्त करें और इसे उल्टा करें, क्योंकि O पोस्टफिक्स नोटेशन का उपयोग करता है
2: ई; 2 को `e` असाइन करें
1: ओ; `O` को 1 में असाइन करें
~ 2% Eval और जाँच करें कि क्या परिणाम है
'O'e? आउटपुट 'ई' यदि भी, 'ओ' यदि विषम हो

Answer 15

जीएनयू सेड, 36

:
s/*oo\|+eo\|+oe/o/
t
s/\W\w\w/e/
t

पोस्ट करने के बाद मैंने इसे बिल्कुल @ manatwork के पर्ल उत्तर और @ randomra के रेटिना उत्तर के समान ही देखा । इसलिए मुझे लगता है कि मैं हर तरह से जा सकता हूं और \W\w\wसाथ ही साथ उधार भी ले सकता हूं ।

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

Comments

कोष्ठक चले जाने के साथ, यह अब विस्तारित रेगेक्स को छोड़ने के लिए भुगतान करता है। आप बचने के लिए 2 बाइट्स जीतते हैं +, आप बचने के लिए 2 बाइट्स खो देते हैं |, लेकिन अंतिम परिणाम यह है कि आप ड्रॉइंग विकल्प के लिए 1 बाइट जीतते हैं -r।

— रूड हेलडरमैन

@Rudud यह सही है। मैंने इसे पहले भी आजमाया था, लेकिन इसका उपयोग न |होने पर बच जाने की जरूरतों का एहसास -rनहीं हुआ। फिर भी, स्कोर से 2 और बाइट्स - धन्यवाद!

— डिजिटल ट्रामा

Answer 16

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

पुकारते हैं f।

f=until((==1).l)r
r s|l s<3=s|3#s?o=r('o':3%s)|3#s?sequence["+*","oe","oe"]=r('e':3%s)|0<1=1#s++r(1%s)
l=length
(#)=take
(%)=drop
(?)=elem
o=["+eo","+oe","*oo"]

Answer 17

जावास्क्रिप्ट, 92 71 बाइट्स

f=i=>i>"0"?i:f(i.replace(/.[eo]{2}/,e=>"eo"[eval((e[1]>"e")+"^&"[+(e[0]<"+")]+(e[2]>"e"))]))

यह थोड़ा अस्पष्ट है, लेकिन मैं कुछ का उपयोग कर evalऔर बिटवाइज़ ऑपरेटरों को करना चाहता था । एनोटेट:

f = (i) => // function(i) { return
    i>"0"  // i[0] == "o" || i[0] == "e" :-) - the characters `*` and `+` are both <"0"
      ? i  // finish
      : f(i.replace( // recursively repeat with
          /.[eo]{2}/, // first occurrence of "something" followed by two values
          (e) =>    // replaced by
              "eo"[ // string indexing
                eval(
                    (e[1]>"e")        // e[1] == "o" ? "true" : "false"
                  + "^&"[+(e[0]<"+")] // e[0] == "+" ? "^" : "&"
                  + (e[2]>"e")        // e[2] == "o" ? "true" : "false"
                )
              ]     // like eval(…) ? "o" : "e"
        ))

बार-बार (e[…]>"e")मुझे थोड़ा परेशान करता है, लेकिन निम्नलिखित बेहतर नहीं है (103 बाइट्स):

f=i=>i>"0"?i:f(i.replace(/e|o/g,x=>+(x>"e")).replace(/.\d\d/,e=>"eo"[eval(e[1]+"^&"[+(e[0]<"+")]+e[2])]))

तो अंत में, सरल विकल्प मिलान के साथ @ अर्काइन का दृष्टिकोण अतिरेक है। कुछ अनुकूलन के साथ एक समारोह में बनाया गया:

f=i=>i>"0"?i:f(i.replace(/.[eo]{2}/,v=>"eo"[+"+oe+eo*oo".includes(v)]))

Answer 18

डार्ट, 173 बाइट्स

f(i){var l=i.split(''),e='e',o='o';g(p){if(l[p]!=e&&l[p]!=o){var x=p+1,y=p+2;g(x);g(y);l[p]=l[p]=='+'?l[x]!=l[y]?o:e:l[x]==o?l[y]:e;l.removeRange(x,p+3);}}g(0);print(l[0]);}

यह प्रतिस्पर्धी नहीं है, लेकिन जो भी हो। समाधान का सार, 0 से शुरू होता है, पुनरावर्ती रूप से प्रत्येक ऑपरेटर को उस ऑपरेटर के बाद पात्रों की जोड़ी के मूल्यांकन से बदल देता है और फिर उन पात्रों को सूची से हटा देता है।

Answer 19

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

यहाँ एक गंभीर भाषा का उपयोग कर एक दृष्टिकोण है;)

गोल्फ संस्करण:

p(s:_)[]=s
p s(x:y)=p(r$x:s)y
r[]=[]
r('e':'e':'+':x)=r$'e':x
r('e':'o':'+':x)=r$'o':x
r('o':'e':'+':x)=r$'o':x
r('o':'o':'+':x)=r$'e':x
r('e':'e':'*':x)=r$'e':x
r('e':'o':'*':x)=r$'e':x
r('o':'e':'*':x)=r$'e':x
r('o':'o':'*':x)=r$'o':x
r x=x

उदाहरण:

*Main> p [] "+**+***+**++**+eooeoeeoeeoeooeo"
'o'

Ungolfed और बहुत व्यापक संस्करण:

type Stack = String

parse :: String -> Char
parse = parse' []

parse' :: Stack -> String -> Char
parse' (s:_) []     = s
parse' s     (x:xs) = parse' (reduce $ x:s) xs

reduce :: Stack -> Stack
reduce [] = []
reduce ('e':'e':'+':xs) = reduce $ 'e':xs
reduce ('e':'o':'+':xs) = reduce $ 'o':xs
reduce ('o':'e':'+':xs) = reduce $ 'o':xs
reduce ('o':'o':'+':xs) = reduce $ 'e':xs
reduce ('e':'e':'*':xs) = reduce $ 'e':xs
reduce ('e':'o':'*':xs) = reduce $ 'e':xs
reduce ('o':'e':'*':xs) = reduce $ 'e':xs
reduce ('o':'o':'*':xs) = reduce $ 'o':xs
reduce xs               = xs

उदाहरण:

*Main> parse "+**+***+**++**+eooeoeeoeeoeooeo"
'o'

विशेषताएं: पैटर्न मिलान और पुनरावृत्ति।

Answer 20

जोल्फ, 11 बाइट्स

(गैर-प्रतिस्पर्धी, जैसा कि भाषा सवाल पोस्ट करती है।) इसे यहां आज़माएं!

FVyAi"oe"@\x12

( \x12वास्तविक चरित्र के साथ बदलें \x12। दुभाषिया में यह स्वचालित रूप से किया जाना चाहिए।)

स्पष्टीकरण:

FVyAi"oe"@\x12
    i          input
          \x12 character 12
         @     char code at
   A "oe"      replace all os with 1s and all es with 2s
  y            eval as jolf, returning the answer
 V             return parity "even" or "odd"
F              get first character
               implicit output

Answer 21

पायथन 3, 171 145 135 बाइट्स

प्रतिस्पर्धी नहीं है, लेकिन मुझे ऐसा करने में मज़ा आया, इसलिए मैं इसे अपने पास नहीं रख सका। Feersum द्वारा (बहुत चालाक) पुनरावर्ती-पुनरावृत्ति पायथन प्रविष्टि के विपरीत , यह एक इनपुट को उलट देता है और फिर रिवर्स पोलिश नोटेशन का एक अच्छा पुराना स्टैक-आधारित पार्सिंग करता है।

def p(i):
 s=[]
 for c in i[::-1]:
  s+=[c>'e'if c>'a'else getattr(s.pop(),'__'+('axnodr'[c>'*'::2])+'__')(s.pop())]
 return'eo'[s[0]]

Comments

यह callable()सुरुचिपूर्ण है, लेकिन लंबा है। (स्थिति को उलटाना और निकालना notकम होगा।) इसके बजाय जांचें कि क्या मी पूर्णांक m in[0,1]छोटा होगा, लेकिन यह जांचने के लिए कि क्या c मान अधिक c in'eo'छोटा होगा। बाद c>'a'में इस मामले में भी ऐसा ही हुआ ।

— मैनटवर्क

वास्तव में चर एम और इसके संख्यात्मक मूल्यों की कोई आवश्यकता नहीं है। इसे केवल अंदर रखें for:s+=[c>'e'if c>'a'else{'*':o.and_,'+':o.xor}[c](s.pop(),s.pop())]

— manatwork

@manatwork: धन्यवाद! मुझे नहीं लगता था कि मैं स्थिति को उलट सकता हूं, क्योंकि मुझे लगा कि s.pop()हर लूप का मतलब (दो बार) कॉलिंग होगा । मैंने अब तक परीक्षण को परेशान नहीं किया; लेकिन हे, बिंदु की अब लूट।

— टिम पैडरिक

एक प्रश्न ने मुझे शुरुआत से परेशान किया: operator मॉड्यूल का उपयोग क्यों ? bool.__and__()और bool.__xor__()हैंडर s+=[c>'e'if c>'a'else getattr(s.pop(),{'*':'__and__','+':'__xor__'}[c])(s.pop())]:। लेकिन के आधार पर gnibbler के टुकड़ा करने की क्रिया टिप , कि में बदला जा सकता s+=[c>'e'if c>'a'else getattr(s.pop(),'__'+('axnodr'[c>'*'::2])+'__')(s.pop())]।

— मैनटवर्क

@manatwork: क्योंकि मैंने ऐसा नहीं सोचा था। मैंने केवल इनफ़िक्स ऑपरेटरों ( ^, &) और उनके operatorसमकक्षों पर विचार किया , उन तरीकों के बारे में भूलकर जो वास्तव में उन्हें लागू करते हैं। ओह, और reversed()अब पायथन गोल्फिंग सुझावों में से एक के लिए धन्यवाद छोड़ दिया गया है ।

— टिम पैडरिक 12

Answer 22

हास्केल, 98 94 बाइट्स

एक और हास्केल प्रयास के साथ आपको परेशान करने के लिए क्षमा करें; सिर्फ यह साबित करना चाहता था कि यह 100 बाइट्स से कम में बहुत अच्छी तरह से संभव है।

p(c:s)|any(<'a')s=p(c:p s)
p('+':x:y:s)|x/=y='o':s
p('*':'o':s)=s
p(c:_:_:s)|c<'a'='e':s
p s=s

एक फ़ंक्शन को परिभाषित करता है pजो किसी भी मान्य अभिव्यक्ति को पैरामीटर के रूप में स्वीकार करता है, और परिणाम को 1 स्ट्रिंग की लंबाई के रूप में वापस करता है।

उदाहरण:

*Main> p "**o++*ee*++eoe*eo+eoo"
"o"

फ़ंक्शन स्ट्रिंग में सही ऑपरेटर को बार-बार कम करके काम करता है जब तक कि कोई ऑपरेटर नहीं छोड़ा जाता है।

Answer 23

++ , 46 बाइट्स जोड़ें

D,g,@,d"oe"$eA"e"=+o
D,f,@,bR€gbU32CjbV2%"eo":

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

पाद लेख बस सभी उदाहरण आदानों और उनके इसी आउटपुट enumerates।

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

यहां उत्तरों के एक खो जाने की तरह, यह प्रतिस्थापन और मूल्यांकन का उपयोग करता है। हमारा मुख्य कार्य है f, और gएक सहायक कार्य है। हम उदाहरण के रूप में "*e*o*e*oe"(जो है e) का उपयोग करेंगे।

fइनपुट स्ट्रिंग लेने और इसे उल्टा करने से शुरू होता है, उपज "eo*e*o*e*"। हम फिर gप्रत्येक तत्व पर नक्शा बनाते हैं:

gअंतिम आदेश तक एक प्रतिलिपि रखने के लिए, तर्क की नकल करके शुरू होता है। हम तब जाँचते हैं कि तर्क स्ट्रिंग में है "oe", अक्षरों के लिए 1 और उपज 0 के लिए *या +। हम फिर से तर्क को धक्का देते हैं और जांचते हैं कि क्या यह बराबर है "e"। यह परिणाम तब पिछले चेक में जोड़ा जाता है। यह 0* या तो के लिए +, 1 के लिए oऔर 2 के लिए उपज देता है e। हम तो तार्किक या इस मूल्य और तर्क के बीच लेते हैं। यदि मान 0 है, यह तर्क (यानी की जगह *या +,) अन्यथा यह छोड़ दिया है के रूप में है (यानी 1 और 2 )।

यह इनपुट के रिवर्स में सभी अक्षरों को संख्यात्मक मान में परिवर्तित करता है। फिर हम प्रत्येक तत्व को रिक्त स्थान से जोड़ने के लिए सुनिश्चित करने के लिए रिक्त स्थान से जुड़ते हैं। हमारे उदाहरण के लिए, यह स्ट्रिंग पैदावार देता है "2 1 * 2 * 1 * 2 *"। इसके बाद हम इसका मूल्यांकन कर सकते हैं, ऐड ++ के पोस्टफिक्स नोटेशन का उपयोग करके, 8 उपज । फिर हम इस मान की समता लेते हैं, या तो संख्याओं के लिए 0 और विषम संख्याओं के लिए 1 या तो स्ट्रिंग में अनुक्रमण करते हैं "eo"और संबंधित अक्षर को वापस करते हैं।