टर्नरी ऑपरेटरों की अभिव्यक्ति का मूल्यांकन करें

Question

वर्णमाला के ऊपर एक व्याकरण पर विचार करें { 0, 1, ?, :} द्वारा परिभाषित उत्पादन नियम

रों → 0┃ 1┃ 0 ?रों :रों ┃ 1 ?रों :रों

एस से उत्पन्न एक स्ट्रिंग को देखते हुए , इसे एक अभिव्यक्ति के रूप में पार्स करें जहां ?:सही-सहयोगी है (उदाहरण के लिए, a?B?X:Y:c?d:e?f:gइसका मतलब है a?(B?X:Y):(c?d:(e?f:g))) और निम्नलिखित शब्दार्थ के साथ इसका मूल्यांकन करें:

eval(0) = 0
eval(1) = 1
eval(0?a:b) = eval(b)
eval(1?a:b) = eval(a)

यदि परिणाम 0 है , तो कुछ निश्चित मूल्य का उत्पादन करें; यदि आउटपुट 1 है , तो आउटपुट एक अलग निश्चित मूल्य है। अपने उत्तर में अपने चुने हुए आउटपुट मान (जैसे 0/ 1, या False/ True) निर्दिष्ट करें ।

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

0 -> 0
1 -> 1
0?0:1 -> 1
0?1:0 -> 0
1?0:1 -> 0
1?1:0 -> 1
0?1?0:1:1 -> 1
1?0?1:1:1 -> 1
1?0:1?0:1?1:1 -> 0
1?1?1:0?1?0:0:0:0 -> 1
1?0:1?0?1:1?1:0:1?1?1:1:1?0:1 -> 0
1?1?1:0?0?1:1:0?1:0:1?1?0?0:0:1?1:0:0?1?0:1:1?0:1 -> 1
0?0?1?0?0:1:0?0:0:0?0?1:1:1?0:1:0?0?0?1:0:0?1:1:1?1?0:1:1 -> 0

नियम

• आप ऐसी भाषा में निर्मित भाषा का उपयोग नहीं कर सकते हैं जो कुछ प्रोग्रामिंग भाषा में कोड के रूप में स्ट्रिंग की व्याख्या करती है और इसे चलाती है (जैसे जावास्क्रिप्ट / पर्ल / रूबी / पायथन के eval)।
• उस ने कहा, आपके कोड को वास्तव में पार्स नहीं करना है और फिर इनपुट स्ट्रिंग का मूल्यांकन करना है। आप किसी भी दृष्टिकोण को बराबर परिणाम प्राप्त कर सकते हैं और पिछले नियम का उल्लंघन नहीं कर सकते।
• आपके कार्यक्रम के खिलाफ जाँच की जाएगी perl -le 'print eval<>'।
• सबसे छोटा कोड (बाइट्स में) जीतता है।

Comments

आम तौर पर स्ट्रिंग को मौलिक रूप से बदलने के बाद स्ट्रिंग की व्याख्या करने वाले eval जैसी भाषा में निर्मित भाषा का उपयोग करने के बारे में कैसे?

— आदम

बिल्डरों के बारे में क्या है जो $ some_other_language कोड के रूप में स्ट्रिंग्स की व्याख्या करते हैं ?

— मेगो

@ Adám यह अस्वीकृत हो जाएगा, क्षमा करें।

— लिन

@Mego हम्म, वहाँ एक तुच्छ धोखा देने का अवसर है, इसलिए मैंने ऐसे सभी बिल्ट-इन को कवर करने के लिए नियम को बढ़ाया।

— लिन

मार्टिन परीक्षण मामलों के प्रकाश में, शायद यह के रूप में व्याकरण को परिभाषित करने के लिए आसान हो जाएगा S → T | T ? S : S, T → 0 | 1, संबद्धता के बारे में बात करने के लिए की आवश्यकता नहीं पड़ती?

— पीटर टेलर

Answer 1

गोल्फस्क्रिप्ट, 21 बाइट्स

2/-1%{)2%{0`=@@if}*}/

यह आउटपुट 0या 1। इनपुट को एक एकल अनुगामी न्यूलाइन माना जाता है। उपयोग करना ~(जो स्ट्रिंग्स का मूल्यांकन करता है) एक बाइट को बचाएगा:

2/-1%{)2%{~!@@if}*}/

यह http://golf.shinh.org/reveal.rb?The+B+Programming+Language/tails_1462638030&gs पर आधारित है ।

Answer 2

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

r-1=+`0\?.:|1\?(.):.
$1

इसे ऑनलाइन आज़माएं! (पहली पंक्ति एक लाइनफ़ीड-पृथक परीक्षण सूट को सक्षम करती है।)

व्याख्या

यह वास्तव में काफी सरल है। बार-बार परिणाम के कारण इनपुट कम हो जाता है ( +) केवल उन शाब्दिकों का मूल्यांकन करना जिनमें केवल शाब्दिक होते हैं। यह सुनिश्चित करने के लिए कि यह सही-संगत रूप से किया गया है, हम दाएं से बाएं ( r) मैच देखते हैं और केवल अंतिम मैच को बदलते हैं जो हम पाते हैं ( -1=)।

रेगेक्स खुद या तो मेल खाता है 0\?.:और इसे हटा देता है (केवल सामान को छोड़कर :) या 1\?.:.इसके बाद के मूल्य के साथ बदल देता है ?।

Comments

यदि रेगेक्स सही से शुरू होता है, तो क्या आपको 1सेंट के बजाय सेंट मैच की प्रक्रिया नहीं करनी चाहिए -1?

— लीक नून

@LeakyNun दुर्भाग्य से, मुझे लगता है कि मैं सीमा लागू करने से पहले मैचों को उलट देता हूं।

— मार्टिन एंडर

Answer 3

हास्केल, 106 101 100 90 83 बाइट्स

यह पैटर्न हास्केल के पैटर्न मिलान क्षमताओं पर बहुत निर्भर करता है। सबसे पहले, हम स्ट्रिंग को इस तरह उलटते हैं कि हम केवल पहली घटना के लिए खोज कर सकते हैं b:a?x(जो सामान्य रूप से पढ़ा जाएगा x?a:b) और इसे इसके मूल्य से बदल दें। यह स्वचालित रूप से सही समरूपता प्रदान करता है । यहां हम x:xsपैटर्न का उपयोग करते हैं । यही कार्य fकर रहा है। तब हम मूल रूप fसे बार-बार इसके उत्पादन पर लागू होते हैं , जब तक कि हमारे पास एक भी संख्या (0 या 1) शेष न हो।

12 बाइट्स के लिए धन्यवाद @Lynn!

f(b:':':a:'?':x:l)|x>'0'=a:l|1>0=b:l
f(x:l)=x:f l
f x=x
until((<2).length)f.reverse

Answer 4

ब्रेनफक, 82 64 63 बाइट्स

+
[
  ,>>,>
  +++++++[<---<<-[------>>]<-]
  <<
  [
    ->[<++>[+]]
  ]
  +>[>>]
  <<<-
]
<.

आउटपुट के \xffलिए 0और के \x00लिए है 1। दिमाग़ी क्रियान्वयन को आरंभिक सेल के बाईं ओर जाने की अनुमति देनी चाहिए।

यह अनिवार्य रूप से xsot के पायथन उत्तर के समान दृष्टिकोण का उपयोग करता है , लेकिन मेरे शुरुआती 82-बाइट सबमिशन की तुलना में ब्रांचिंग का पालन करना कठिन है:

-
[
  +
  [
    ->,,>+++++++[<--------->-]
    <[<++>[+]]
    <
  ]
  ,->,>+++++++[<[-------<]>>-->-]
  <[<]
  <
]
>>.

(इस समाधान के लिए, उत्पादन होता है \xfeके लिए 0और \xffके लिए 1, और व्यापक अनुकूलता एक नई पंक्ति के साथ हासिल की है जब इनपुट समाप्त होता है।)

अगर आपको xsot के समाधान का विश्लेषण करने के लिए परेशान नहीं किया जा सकता है, तो विचार यह है: बाएं से दाएं आगे बढ़ें। यदि आप देखते हैं 1?तो लालच से इसे त्याग दें। यदि आप देखते हैं 0?तो उस और संबंधित के बीच सब कुछ त्यागें :। जब ?दूसरे वर्ण के रूप में प्रकट नहीं होता है, तो लूप करना बंद करें और शेष स्ट्रिंग के पहले चरित्र को प्रिंट करें।

तो, 82-बाइट समाधान वास्तव में उस योजना को बहुत करीब से दिखाता है। आंतरिक लूप हैंडल करता है 0?, जैसे कि xsot का इनर लूप। किसी भी इनपुट वर्णों की जांच के बिना मुख्य लूप में प्रवेश करने के लिए कुछ देखभाल की जाती है; यानी, हम यह जांचना चाहते हैं कि क्या ?मुख्य लूप के अंत में दूसरा चरित्र सिर्फ एक बार है, और मुख्य लूप में प्रवेश करने से पहले शुरुआत में भी नहीं।

63-बाइट समाधान अनिवार्य रूप से आंतरिक और बाहरी छोरों को एक में जोड़ता है, जो मुझे संदेह था कि उन छोरों के बीच समानता दी गई थी। मुख्य लूप में मेमोरी लेआउट को निम्न के रूप में वर्णित किया जा सकता है:

[s] d c

जहां [x]साधन वर्तमान सेल - sएक डमी अशून्य मूल्य सिर्फ इंगित करता है कि हम अभी भी पाशन कर रहे हैं, और तुरंत एक इनपुट चरित्र (या तो साथ ओवरराइट है के रूप में शुरू होता है 0या 1)। dसेल (नकारात्मक) गहराई मामले में हम एक के बीच में हैं रखती है 0?, नहीं तो 0। cया तो होने जा रहा है ?या :या न्यू लाइन या EOF।

अपडेट करने के बाद sऔर c, हम पॉइंटर के अनुसार और एडजस्ट करके 0?मामले को संभालते हैं d, अन्यथा हम अगले पुनरावृत्ति में cमूल्य के वर्तमान मान का उपयोग करते हैं d, या यदि हम कर रहे हैं तो रुक जाते हैं।

Answer 5

पायथन 2, 76 74 73 72 बाइट्स

a=`id`
for c in input()[::-1]:a=(c+a,a[ord(c)*7%9]+a[4:])[a>'?']
print a

से बचने के लिए स्ट्रिंग शाब्दिक के रूप में इनपुट के साथ raw_।

आउटपुट है 0या 1उसके बाद <built-in function id>।

Comments

हाहा, मैंने अभी बी लैंग के लिए आपका जवाब पढ़ा और लगभग एक समान उत्तर पोस्ट करने वाला था! यहाँ एक अतिरिक्त अनुकूलन है:3>>int(c)

— xsot

यह समझाने के लिए कि यह कैसे काम करता है? वास्तव में साफ दिखता है

— WorldSEnder

@WorldSEnder मुझे लगता है कि यह एक प्रकार का समाधान है जिसके साथ आने के लिए मुश्किल हो सकता है, लेकिन इसे देखने के बाद समझने में आसान है। यह स्ट्रिंग के माध्यम से पीछे की ओर चलता है और बार-बार सही स्थिति को संसाधित करता है, जैसा कि अन्य सॉल्वरों ने भी किया है।

— मिच श्वार्ट्ज

वह `id`चाल…! शाबाश :)

— लिन

Answer 6

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

s=input()
while'?'<=s[1:]:
 n=s<'1'
 while n:s=s[2:];n+=-(s[1]<'?')|1
 s=s[2:]
print s[0]

इनपुट को एक स्ट्रिंग शाब्दिक के रूप में लिया जाता है।

Answer 7

ग्रिम , 34 31 बाइट्स

E=d|d\?E.E
e`\1|\1\?_.E|\0\?E._

1सत्य आदानों के लिए और 0झूठे लोगों के लिए प्रिंट । इसे ऑनलाइन आज़माएं! पिछले परीक्षण का मामला दुर्भाग्य से टीआईओ पर स्मृति से बाहर है।

व्याख्या

राइट संबद्धता अनिवार्य रूप से मतलब है कि a?b:c, aहमेशा या तो है 0या 1एक लंबे समय तक अभिव्यक्ति कभी नहीं,। मैं सिर्फ एक पैटर्न को पुनरावर्ती रूप से परिभाषित करूंगा जो उस तरह की एक सत्य अभिव्यक्ति से मेल खाता है, और इसके खिलाफ इनपुट की जांच करें। यह जाँचना भी अनावश्यक है कि प्रत्येक :वास्तव में है :, यदि ?सभी की जाँच की जाती है: इनपुट में ?s और :s की समान संख्या है , और यदि कुछ ?को गलत तरीके से वर्गीकृत किया गया है :, तो :मिलान करने में विफल रहेगा, और Grime का मिलान इंजन पीछे हट जाएगा।

E=d|d\?E.E
E=                      Define nonterminal E (for "expression") as
  d|                     a digit, OR
    d                    a digit,
     \?                  a literal ?,
       E                 a match of E,
        .                any character (will match a :), and
         E               another match of E.
e`\1|\1\?_.E|\0\?E._
e`                      Match entire input against this pattern (truthy expression):
  \1|                    a literal 1, OR
     \1\?                a literal 1?,
         _               a recursive match of truthy expression,
          .              any character (will match a :), and
           E|            any expression, OR
             \0\?E._     the same, but with 0 in front, and _ and E swapped.

Answer 8

हास्केल, 79 71 70 62 60 56 बाइट्स

संपादित करें: 3 बाइट्स के लिए @ ज़र्ब और 4 बाइट्स के लिए @ निमि के लिए धन्यवाद!

e(x:'?':r)|a:_:s<-e r=last$e s:[a:tail(e s)|x>'0']
e x=x

यह एक पुनरावर्ती दृष्टिकोण है जो कुछ हद तक "कुछ निश्चित मूल्य"-नियम का दुरुपयोग करता है । संपादित करें: टुपल्स से छुटकारा पाने से न केवल 8 बाइट्स बचते हैं, यह एक अच्छे आउटपुट भी देता है: "0"या "1"।

Ungolfed संस्करण:

eval (x:'?':r1) = if x=='1' then (a, r3) else (b, r3)
    where (a,':':r2) = eval r1
          (b, r3)    = eval r2
eval (x:r) = (x,r)

यह कैसे काम करता है? समारोह अभिव्यक्ति की अंतर्निहित पेड़ को पार करता
eval

eval 1?0?0:1:0?1:0 -> eval 1?          :
                             eval 0?0:1 eval 0?1:0

और फॉर्म का एक टपल लौटाता है (result, rest)।
पहले पैटर्न में और से (x:'?':r1)मेल खाता है । उप-अभिव्यक्ति और रिटर्न का मूल्यांकन करने के लिए पुनरावर्ती रूप से आवेदन करना । पैटर्न पैदावार के लिए यह मिलान और । इससे उप-सूत्र भी रिकर्सिवली कि इतने मूल्यांकन किया जाता है और । जाँच करें कि क्या है या या तो लौटाएँ या ।x'1'r1"0?0:1:0?1:0"evalr10?0:1(0,":0?1:0")(a,':':r2)a=0r2=0?1:0b='0'r3=""x'1''0'(a, r3)(b, r3)

Comments

अच्छा तरीका! के x>'0'स्थान पर काम करेगा x=='1'?

— ज़गारब

धन्यवाद, मैंने यह नहीं सोचा था कि चार्ट के साथ काम करते समय।

— लिकोनी

मैं लगता है कि तुम भी बदल सकते हैं ':'द्वारा _।

— ज़र्गब

हाँ, तो कोड भी सिर्फ के बजाय मनमाना delimiters के लिए काम करता है :। एक बार फिर धन्यवाद!

— लकोनी

अच्छा! आप के if .. then .. elseसाथ बदल सकते हैं last$e s:[a:tail(e s)|x>'0']।

— नमि

Answer 9

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

f=s=>s[1]?f(s.replace(/0\?.:|1\?(.):.(?!\?)/,"$1")):s

रिटर्न 0या 1वैध इनपुट के लिए; अमान्य इनपुट के लिए हैंग हो जाता है। स्पष्टीकरण: क्योंकि एक स्ट्रिंग को उलटना जावास्क्रिप्ट में अजीब है, मेरे पहले 71-बाइट के प्रयास ने नकारात्मक लुकहेड का उपयोग करके काम किया है ?जो अन्यथा सहानुभूति को परेशान करेगा:

f=s=>s[1]?f(s.replace(/(.)\?(.):(.)(?!\?)/,(_,a,b,c)=>+a?b:c)):s

चूँकि यह कुछ समय के लिए था, इसलिए मुझे आश्चर्य हुआ कि क्या मैं निर्णय लेने में सुधार करके मामलों को सुधार सकता हूँ। जैसा कि यह निकला, यह एक तत्काल सफलता नहीं थी, क्योंकि इसमें 71 बाइट्स भी लगे:

f=s=>s[1]?f(s.replace(/0\?.:(.)(?!\?)|1\?(.):.(?!\?)/,"$1$2")):s

फिर यह मेरे साथ हुआ 0?0:और 0?1:हमेशा सहयोग के लिए चिंता किए बिना, ऑप्स हैं। इसने मुझे लगभग 25% बचाया।

Comments

शीर्ष पर आपका कोड ब्लॉक गायब है f=। मैंने जाँच नहीं की है कि आपकी बाइट गिनती खाते में ले रही है या नहीं।

— पैट्रिक रॉबर्ट्स

@PatrickRoberts मैं हमेशा से ऐसा कर रहा हूं, क्योंकि मैं लॉग से कॉपी करता हूं, जो केवल असाइनमेंट का परिणाम दिखाता है (जो कि निश्चित रूप से नॉनक्रैसिव कार्यों के लिए पर्याप्त है)।

— नील

@ नील आप आउटपुट के बजाय लॉग इनपुट से कॉपी कर सकते हैं

— ASCII-only

@MarsUltor लॉग इनपुट में प्रॉम्प्ट शामिल है, जिसे मुझे फिर बाहर करना याद रखना होगा। यह गैर-पुनरावर्ती कार्यों के लिए एक अजीब अतिरिक्त कदम है, यही वजह है कि मैं डिफ़ॉल्ट रूप से आउटपुट से कॉपी करता हूं।

— नील

Answer 10

पर्ल, 32 + 1 ( -pध्वज) = 33 बाइट्स

@ मिच स्वार्च को पूरा श्रेय , क्योंकि उसका समाधान मेरे से 14 बाइट छोटा था! @Neil को
भी धन्यवाद जिन्होंने मिच की तुलना में 1 बाइट का समाधान सुझाया।

s/.*\K(0\?..|1\?(.)..)/\2/&&redo

-pझंडे की जरूरत है , साथ ही साथ -M5.010या -Eचलाने के लिए। उदाहरण के लिए :

perl -pE 's/.*\K(0\?..|1\?(.)..)/\2/&&redo' <<< "0
0?0:1
0?1?0:1:1
1?0:1?0?1:1?1:0:1?1?1:1:1?0:1
0?0?1?0?0:1:0?0:0:0?0?1:1:1?0:1:0?0?0?1:0:0?1:1:1?1?0:1:1"

स्पष्टीकरण : यह मूल रूप a?b:cसे तब तक के ब्लॉक को कम करता है (जो शुरू से ही निश्चित रूप से कोई ?अनुसरण नहीं करता है) में bया cउसके aऊपर और तब तक की सच्चाई पर निर्भर करता है जब तक कि स्ट्रिंग में केवल 1या नहीं होता है 0।

Comments

क्या -आपके स्कोर की गिनती नहीं है? मानव संसाधन विकास मंत्री। दिलचस्प ... अच्छा जवाब!

— मेयोरमोनी

@MayorMonty 1-लाइनर के लिए आप इसे कमांड लाइन पर प्रयोग कर सकते हैं और perl -e '<code>'इस प्रकार pकेवल 1 बाइट को जोड़ सकते हैं perl -pe '<code>'।

— नील

@ नील अहह, जो समझ में आता है

— मेयरमोनी

वास्तव में आपको स्ट्रिंग को उल्टा करने की ज़रूरत नहीं है, आप केवल नकारात्मक रूप से देख सकते हैं ?, मैं इस तरह से 34 बाइट्स काट सकता हूं।

— नील

यहाँ एक 32 + 1 है:s/.*\K(1\?(.)..|0\?..)/\2/&&redo

— मिच श्वार्ट्ज

Answer 11

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

def f(s):z=s.pop;r=z(0);return s and':'<z(0)and(f(s),f(s))[r<'1']or r

इनपुट पात्रों की सूची के रूप में स्ट्रिंग है, आउटपुट "0"या तो है"1"

>>>f(list("0?0:1"))
<<<"1"

---

Ungolfed संस्करण:

def parse(s):
    predicate = s.pop(0)
    if s and s.pop(0) == '?':
        left, right = parse(s), parse(s)
        if predicate == '0':
            return right
        return left
    return predicate

---

एक और कोशिश, लेकिन काफी अधिक बाइट्स के साथ:

i=input()[::-1]
a=[i[0]]
for o,z in zip(i[1::2],i[2::2]):a+=[z]if o<'?' else[[a.pop(),a.pop()][z>'0']]
print(a[0])

Comments

आपका उत्तर एक कार्य हो सकता है - आप दूसरी पंक्ति को हटा सकते हैं।

— लिन

यह स्पष्ट रूप से अप्रयुक्त है, क्योंकि यह परीक्षण मामलों को पारित नहीं करता है, और अनगुल्ड संस्करण रनटाइम त्रुटि देता है। आपका मूल विचार हालांकि अच्छा है। कुछ समायोजन के साथ मुझे अजगर 2 में 68 और अजगर 3 में 69 मिले।

— मिच श्वार्ट्ज

वैसे मुझे लगता है कि मेरे लिए इसे अपने आप में संपादित करने की तुलना में आपको जवाब देने के लिए अधिक समझ में आता है (क्योंकि मैं आपके उत्तर को देखने से पहले इस तरह के दृष्टिकोण के बारे में नहीं सोच रहा था) या आपके उत्तर के छोटी होने तक प्रतीक्षा करने के लिए चारों ओर बैठना। यहाँ पर मैंने ६ mentioned का उल्लेख किया है def f(s):x=s.pop(0);return[]<s<s.pop(0)>'>'and(f(s),f(s))[x<'1']or x, और ३ छोटे से दूरी के साथ आपके लिए, वहाँ है def f(s):z=s.pop;r=z(0);return s and':'<z(0)and(f(s),f(s))[r<'1']or r।

— मिच श्वार्ट्ज

धन्यवाद @MitchSchwartz, बहुत अधिक पार्स दाईं ओर से, बाएं के बजाय, gotcha

— WorldSEnder

दूसरा, दाईं ओर के बजाय, ~~~

— WorldSEnder

Answer 12

SED, 75 74 68 (40 + 1 -r) 41

:
s,(.*)1\?(.):.,\1\2,
s,(.*)0\?.:,\1,
t

Comments

आप शायद उनकी टिप्पणी में @ MitchSchwartz की चाल का उपयोग करके इसे काट सकते हैं , हालांकि आपको (.*)अतिरिक्त प्रतिस्थापन शब्द का उपयोग और जोड़ना पड़ सकता है ।

— नील

@ नहीं, आप सही हो सकते हैं, लेकिन मैं यह नहीं समझ सकता कि इसे कैसे काम किया जाए।

— रिले

मैंने इसे चैट में लिखा है, क्योंकि एक टिप्पणी में प्रारूपण करना भ्रामक हो सकता है: chat.stackexchange.com/transcript/message/31709640#31709640

— मिच श्वार्ट्ज

@ मिचस्वार्ट्ज हेह, रिक्त लेबल काम करते हैं? लेकिन मुझे लगता है कि आप \3इसके बजाय मतलब था \2। इसके अलावा, आप ;पाने के लिए लाइनों के साथ जुड़ सकते हैं :;s/(.*)(1\?(.):.|0\?.:)/\1\3/;t।

— नील

@ नील मेरे पास \3इतना था कि इसका मतलब है कि मैंने गलती से एक पिछले संस्करण की नकल की थी। मुझे अर्धविराम के बारे में पता है। लेकिन हाँ, आप अर्धविराम का उपयोग क्यों करना चाहेंगे।

— मिच श्वार्ट्ज

Answer 13

बैश + जीएनयू उपयोगिताओं, 42

rev|sed -r ':
s/(.):.\?0|.:(.)\?1/\1\2/
t'

अधिकांश अन्य पैटर्न-मिलान उत्तरों के समान विचार।

Ideone ।

Comments

आपको 0मामले में पहले चरित्र को पकड़ने की आवश्यकता नहीं है , जो आपको 5 बाइट्स बचाता है।

— नील