कोष्ठक के रूप में कोष्ठक और कोष्ठक का मूल्यांकन

Question

एक प्रोग्राम लिखें जो ()[]इन बिंदुओं को पूरा करने वाले चार वर्णों की एक स्ट्रिंग में लेता है :

• हर बाईं कोष्ठक (में एक मिलान दाईं कोष्ठक होता है )।
• हर बायीं ब्रैकेट [में एक मैचिंग राइट ब्रैकेट होता है ]।
• कोष्ठक और कोष्ठक के जोड़े का मिलान नहीं होगा। उदाहरण [(])अमान्य है क्योंकि मिलान करने वाले कोष्ठक पूरी तरह से मेल खाते हुए कोष्ठकों में सम्‍मिलित नहीं हैं, न ही इसके विपरीत।
• प्रथम और अंतिम वर्ण कोष्ठक या कोष्ठक की एक जोड़ी है। तो ([]([]))और [[]([])]मान्य हैं, लेकिन []([])नहीं है।

( इनपुट प्रारूप के लिए एक व्याकरण है <input> ::= [<input>*] | (<input>*)।)

कोष्ठक और कोष्ठक मिलान की प्रत्येक जोड़ी एक गैर-नकारात्मक पूर्णांक का मूल्यांकन करती है:

• कोष्ठक के मिलान के अंदर जोड़े के मूल्य सभी अभिव्यक्त किए गए हैं । खाली मैच ()का मूल्य है 0।
• मिलान ब्रैकेट के अंदर जोड़े के मूल्य सभी गुणा हैं । खाली मैच []का मूल्य है 1।

^{( एक संख्या का योग या उत्पाद एक ही संख्या है।)}

उदाहरण के लिए, ([](())([][])[()][([[][]][][])([][])])नीचे तोड़ा और मूल्यांकन किया जा सकता है 9:

([](())([][])[()][([[][]][][])([][])])    <input>
(1 (0 )(1 1 )[0 ][([1 1 ]1 1 )(1 1 )])    <handle empty matches>
(1 0   2     0   [(1     1 1 )2     ])    <next level of matches>
(1 0   2     0   [3           2     ])    <and the next>
(1 0   2     0   6                   )    <and the next>
9                                         <final value to output>

एक और उदाहरण:

[([][][][][])([][][])([][][])(((((([][]))))))]    <input>
[(1 1 1 1 1 )(1 1 1 )(1 1 1 )((((((1 1 ))))))]
[5           3       3       (((((2     )))))]
[5           3       3       ((((2       ))))]
[5           3       3       (((2         )))]
[5           3       3       ((2           ))]
[5           3       3       (2             )]
[5           3       3       2               ]
90                                                <output>

आपके प्रोग्राम को संपूर्ण इनपुट स्ट्रिंग द्वारा प्रस्तुत पूर्णांक का मूल्यांकन और प्रिंट करने की आवश्यकता है। आप मान सकते हैं कि इनपुट वैध है। बाइट्स में सबसे छोटा कोड जीतता है।

एक कार्यक्रम के बजाय, आप एक फ़ंक्शन लिख सकते हैं जो एक स्ट्रिंग में प्रिंट करता है और पूर्णांक देता है।

Comments

पायथन की ओर से स्पष्टीकरण के लिए प्रस्तुत करना: केवल कार्यक्रम, या कार्य / वापसी मूल्य ठीक हैं?

— Sp3000

प्रश्न को संपादित करना अच्छा हो सकता है। पिछले प्रश्न में, मुझे बताया गया था कि यदि यह प्रश्न में "प्रोग्राम लिखें" तो यह कहता है कि फ़ंक्शन मान्य नहीं हैं।

— रेटो कोराडी

Answer 1

सीजेम, २३

q"])(""1]:*0]:+["4/ers~

BIG के साथ डेनिस को श्रेय! इसे ऑनलाइन आज़माएं

स्पष्टीकरण:

कार्यक्रम इनपुट को CJam अभिव्यक्ति में परिवर्तित करता है और फिर उसका मूल्यांकन करता है।
[…]बन जाता है […1]:*(1 जोड़ें और गुणा करें)
(…)बन जाता है […0]:+(जोड़ 0 और जोड़ें)

q              read input
"])("          characters we want to replace
"1]:*0]:+["    replacement strings, concatenated
4/             split into strings of length 4: ["1]:*" "0]:+" "["]
er             replace (transliterate) the 3 characters with the 3 strings
s              convert the result (mixed characters and strings) to string
~              evaluate

Comments

लिप्यंतरण 4 बाइट्स बचाता है:q"])(""1]:*0]:+["4/ers~

— डेनिस

@ डेसा वाला! यह पागल है, आप ऐसा कर सकते हैं ??

— एडिट्स

तुम मुझसे पूछ रहे हो ? : पी

— डेनिस

@ डेनिस सीजेएम के निर्माता को ऐसी सुविधा के अस्तित्व के बारे में कैसे पता चलेगा ??

— ऑप्टिमाइज़र

Answer 2

आम लिस्प - 98

(lambda(s)(eval(read-from-string(#1=ppcre:regex-replace-all"\\["(#1#"]"(#1#"\\("s"(+")")")"(*"))))

1. (द्वारा प्रतिस्थापित करें(+
2. [द्वारा प्रतिस्थापित करें(*
3. ]द्वारा प्रतिस्थापित करें)
4. स्ट्रिंग से पढ़ें
5. eval

इसके लिए cl-ppcreलाइब्रेरी को वर्तमान लिस्प छवि में लोड करने की आवश्यकता होती है ।

व्याख्या

कार्य *और +परिवर्तनशील होते हैं और जब कोई तर्क नहीं दिया जाता है तो अपना तटस्थ मूल्य वापस करते हैं। आपके उदाहरणों के लिए, मूल्यांकन किए गए लिस्प फॉर्म निम्नलिखित हैं:

(+ (*) (+ (+)) (+ (*) (*)) (* (+)) (* (+ (* (*) (*)) (*) (*)) (+ (*) (*))))
=> 9

तथा

(* (+ (*) (*) (*) (*) (*)) (+ (*) (*) (*)) (+ (*) (*) (*))
   (+ (+ (+ (+ (+ (+ (*) (*))))))))
=> 90

रीगेक्स के बिना - 183 बाइट्स

(lambda(s)(do(r(x(coerce s'list))c)((not x)(eval(read-from-string(coerce(reverse r)'string))))(setq c(pop x))(push(case c(#\[ (push #\* r)#\()(#\] #\))(#\( (push #\+ r) #\()(t c))r)))

C'mon, लिस्प - 16 बाइट्स (प्रयोगात्मक)

+((<r*([<r)]<rRE

अन्य भाषाएं इतनी अधिक प्रचलित हैं कि मुझे छोटे कड़े हेरफेर के लिए कॉमन लिस्प पर आधारित अपनी गोल्फ भाषा बनाने के लिए लुभाया जाता है। वर्तमान में कोई युक्ति नहीं है, और eval फ़ंक्शन निम्नलिखित है:

(defun cmon-lisp (expr &rest args)
  (apply
   (lambda (s)
     (let (p q)
       (loop for c across expr
             do (case c
                  (#\< (push (pop p) q))
                  (#\r
                   (let ((a1 (coerce q 'string)) (a2 (coerce p 'string)))
                     (setf p nil
                           q nil
                           s
                             (cl-ppcre:regex-replace-all
                              (cl-ppcre:quote-meta-chars a1) s a2))))
                  (#\R
                   (setf s
                           (if (string= s "")
                               nil
                               (read-from-string s))))
                  (#\E (setf s (eval s)))
                  (t (push c p))))
       s))
   args))

टेस्ट:

(cmon-lisp "+((<r*([<r)]<rRE" "([] [] ([] []))")
=> 4

• वहाँ एक निहित तर्क कहा जाता है sऔर दो ढेर, pऔर q।
• स्रोत कोड में वर्णों को धकेल दिया जाता है p।
• <: चबूतरे से pऔर धकेलता है q।
• r: बदलता s(कोई स्ट्रिंग होना चाहिए) वर्ण से में qमें charactes लिए p; परिणाम में संग्रहीत किया जाता है s; pऔर qखाली कर दिया जाता है।
• R: स्ट्रिंग से पढ़ें s, चर में परिणाम की दुकान s।
• E: eval form s, store result में s।

Comments

यहां पर कोष्ठक के साथ कुछ करने के लिए लिस्प का उपयोग कैसे किया जाता है, यह मजेदार है।

— सिड केर्खोव

@SydKerckhove आप टिप्पणी करते हैं, बस मुझे एक उपयुक्त क्लोज़र उत्तर के बारे में सोचना चाहिए। आपका बहुत बहुत धन्यवाद!

— coredump

Answer 3

पायथ, 35 34 33 बाइट्स

L?*F+1yMbqb+YbsyMbyvsXzJ"])"+R\,J

प्रदर्शन।

1 बाइट @ जेक्यूब को धन्यवाद।

हम इनपुट पार्स करके शुरू करते हैं। इनपुट प्रारूप पायथन के करीब है, लेकिन काफी नहीं है। हमें प्रत्येक कोष्ठक या कोष्ठक समूह के बाद अल्पविराम की आवश्यकता है। कोष्ठक समूह के अंत में अल्पविराम अनावश्यक है, लेकिन हानिरहित है। इसे पूरा करने के लिए, हम इस कोड का उपयोग करते हैं:

vsXzJ"])"+R\,J
  X               Translate
   z              in the input
     "])"         the characters "])"
    J             which we will save to J to
             J    J
         +R\,     with each character mapped to itself plus a ",".
 s                Combine the list to a string.
v                  Evaluate as a Python literal.

यह ,स्ट्रिंग के अंत में एक अतिरिक्त छोड़ देगा , जो पूरी वस्तु को एक टुपल में लपेट देगा, लेकिन यह हानिरहित है, क्योंकि टुपल को अभिव्यक्त किया जाएगा, और इसलिए इसके तत्व के बराबर मूल्य होगा।

अब जब स्ट्रिंग को पार्स कर दिया जाता है, तो हमें उसका मूल्य ज्ञात करना चाहिए। यह एक उपयोगकर्ता परिभाषित फ़ंक्शन का उपयोग करके किया जाता है y, जिसे पार्स ऑब्जेक्ट पर कहा जाता है। फ़ंक्शन को निम्नानुसार परिभाषित किया गया है:

L?*F+1yMbqb+YbsyMb
L                     Define a function, y(b), which returns the following:
 ?       qb+Yb        We form a ternary whose condition is whether the input, b,
                      equals the inputplus the empty list, Y. This is true if
                      and only if b is a list.
      yMb             If so, we start by mapping y over every element of b.
  *F+1                We then take the product of these values. The +1 ensures
                      that the empty list will return 1.
                yMb   Otherwise, we start by mapping y over every element of b.
               s      Then, we sum the results.

Comments

@ जाकुब सही, एकात्मक योग का कोई प्रभाव नहीं है।

— ईसैक

Answer 4

एमएसीएस लिस्प, 94

प्रारूप बहुत ही खस्ता लग रहा है, इसलिए मैंने सोचा कि एक साधारण परिवर्तन काम कर सकता है:

(defun e()(format-replace-strings'(("("."(+")("["."(*")("]".")")))(eval(read(buffer-string))))

मध्यवर्ती प्रारूप कुछ ऐसा दिखता है (उदाहरण के लिए प्रश्न में):

(+(*)(+(+))(+(*)(*))(*(+))(*(+(*(*)(*))(*)(*))(+(*)(*))))

हम इस तथ्य से मदद करते हैं कि जोड़ और गुणा पहले से ही हम खाली तर्क सूची के साथ चाहते हैं।

ख़ुशी का खेल खेलने के लिए, उपास्थि और संवादात्मक:

(defun paren_eval()
  (interactive "*")
  (format-replace-strings '(("(" . "(+")
                            ("[" . "(*")
                            ("]" . ")")))
  (eval (read (buffer-string)))
)

Comments

मुझे और अधिक बारीकी से पढ़ना चाहिए था - आम लिस्प समाधान बिल्कुल समान दृष्टिकोण लेता है!

— टोबे स्पाइट

हम और अधिक Emacs लिस्प के जवाब की जरूरत है! Btw, मेरी गिनती नहीं थी लेकिन आप लैम्बडा का उपयोग करके इसे थोड़ा और गोल्फ कर सकते हैं, एक स्ट्रिंग को पैरामीटर के रूप में ले सकते हैं और हटा सकते हैं interactive (बफ़र-स्ट्रिंग के बजाय, रीड-से-स्ट्रिंग का उपयोग करें)।

— coredump

Answer 5

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

[\([](1+x)[]\)]
$1
\[]
1x
\(\)
x
(\[a*)1(?=1*x1*x)
$1a
a(?=a*x(1*)x)
$1
(\[1*x)1*x
$1
)`(\(1*)x(?=1*x)
$1
[^1]
<empty line>

उत्पादन में एकता देता है।

प्रत्येक पंक्ति को अपनी फ़ाइल पर जाना चाहिए लेकिन आप -sध्वज के साथ एक फ़ाइल के रूप में कोड चला सकते हैं । उदाहरण के लिए:

> retina -s brackets <input_1
111111111

स्पष्टीकरण बाद में आता है।

Answer 6

जावा, 349 वर्ण

एक सरल पुनरावर्ती दृष्टिकोण। प्रोग्राम को कॉल करने के लिए उपयोग किए जाने वाले पहले तर्क के लिए स्ट्रिंग की अपेक्षा करता है।

import java.util.*;class K{int a=0,b;String c;public static void main(String[]a){K b=new K();b.c=a[0];System.out.print(b.a());}int a(){switch(c.charAt(a++)){case'(':b=0;for(int a:b())b+=a;break;case'[':b=1;for(int a:b())b*=a;}a++;return b;}List<Integer>b(){List d=new ArrayList();char c;while((c=this.c.charAt(a))!=']'&&c!=')')d.add(a());return d;}}

विस्तारित:

import java.util.*;

class K {
    int a =0, b;
    String c;
    public static void main(String[] a){
        K b = new K();
        b.c = a[0];
        System.out.print(b.a());
    }
    int a(){
        switch (c.charAt(a++)){
            case '(':
                b =0;
                for (int a : b())
                    b += a;
                break;
            case '[':
                b =1;
                for (int a : b())
                    b *= a;
        }
        a++;
        return b;
    }
    List<Integer> b(){
        List d = new ArrayList();
        char c;
        while ((c= this.c.charAt(a)) != ']' && c != ')')
            d.add(a());
        return d;
    }
}

Answer 7

पर्ल 5, 108

फिर से लिखने और विकसित करने के बजाय दुभाषिया के रूप में किया गया। एक महान दिखावा नहीं है, लेकिन वैसे भी लिखने के लिए मजेदार है।

push@s,/[[(]/?[(ord$_&1)x2]:do{($x,$y,$z,$t)=(@{pop@s},@{pop@s});
[$t?$x*$z:$x+$z,$t]}for<>=~/./g;say$s[0][0]

संयुक्त राष्ट्र के golfed:

# For each character in the first line of stdin
for (<> =~ /./g) {
    if ($_ eq '[' or $_ eq '(') {
        # If it's an opening...
        # ord('[') = 91 is odd, ord('(') = 40 is even
        push @stack, [ ( ord($_) & 1) x 2 ];
        # so we will push [1, 1] on the stack for brackets and [0, 0] for parens.
        # one of these is used as the flag for which operator the context is, and
        # the other is used as the initial (identity) value.
    } else {
        # otherwise, assume it's a closing
        ($top_value, $top_oper) = @{ pop @stack };
        ($next_value, $next_oper) = @{ pop @stack };
        # merge the top value with the next-to-top value according to the
        # next-to-top operator. The top operator is no longer used.
        $new_value = $next_oper
            ? $top_value * $next_value
            : $top_value + $next_value
        push @stack, [ $new_value, $next_oper ];
    }
}

say $stack[0][0]; # print the value remaining on the stack.

Answer 8

अजगर, ९९

मैंने कई तरह के तरीके आजमाए, लेकिन जो सबसे छोटी चीज मुझे मिली वह मूल रूप से सिर्फ एक प्रतिस्थापन और प्रमाण थी। मुझे यह जानकर सुखद आश्चर्य हुआ कि मैं सभी अनुगामी को छोड़ सकता हूं ,, जैसा कि पाइथन को पार्स कर सकता है [1,2,]और अंतिम अनुगामी अल्पविराम पूरी बात को तुच्छ बनाता है। केवल अन्य गैर सीधा हिस्सा होगा ord(c)%31%7विभिन्न चरित्रों बाहर अलग करने (यह मूल्यांकन करता है करने के लिए 2, 3, 1, 0के लिए (, ), [, ]क्रमशः)

F=lambda s:eval(''.join(["],1),","reduce(int.__mul__,[","sum([","]),"][ord(c)%31%7]for c in s))[0]

Comments

यह एक कार्यक्रम के रूप में काम नहीं करता है, करता है? सवाल एक कार्यक्रम के लिए पूछता है, इसलिए मुझे नहीं लगता कि एक फ़ंक्शन प्रदान करना आवश्यकताओं को पूरा करता है। कम से कम यही है कि लोगों ने मुझे आखिरी बार कहा था जब मैंने एक फ़ंक्शन सबमिट किया था जब उसने प्रश्न में "प्रोग्राम" कहा था। :)

— रेटो कोराडी

Answer 9

जावा, 301

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

enum E{I;String n;public static void main(String[]r){I.n=r[0];System.out.print(I.e());}int e(){int v=0;if(n.charAt(0)=='('){for(s("(");n.charAt(0)!=')';)v+=e();s(")");}else if(n.charAt(0)=='['){v=1;for(s("[");n.charAt(0)!=']';)v*=e();s("]");}return v;}void s(String c){n=n.substring(1+n.indexOf(c));}}

विस्तार:

enum EvaluatingParenthesesAndBrackets{
    AsIntegers;
    String input;
    public static void main(String[]args){
        AsIntegers.input=args[0];
        System.out.print(AsIntegers.evaluate());
    }
    int evaluate(){
        int value=0;
        if(input.charAt(0)=='('){
            for(substringAfterChar("(");input.charAt(0)!=')';)
                value+=evaluate();
            substringAfterChar(")");
        }
        else if(input.charAt(0)=='['){
            value=1;
            for(substringAfterChar("[");input.charAt(0)!=']';)
                value*=evaluate();
            substringAfterChar("]");
        }
        return value;
    }
    void substringAfterChar(String character){
        input=input.substring(1+input.indexOf(character));
    }
}

Answer 10

पायथन, 117 110 109 बाइट्स

def C(s,p=[0]):
 m=r=s[p[0]]=='[';p[0]+=1
 while s[p[0]]in'[(':t=C(s,p);r=r*t*m+(r+t)*(1-m)
 p[0]+=1;return r

एक पहलू जिसके साथ मैं संघर्ष कर रहा था वह यह है कि फ़ंक्शन में मूल रूप से दो रिटर्न मान हैं: उत्पाद / राशि, और स्ट्रिंग में नई स्थिति। लेकिन मुझे एक फ़ंक्शन की आवश्यकता होती है जो केवल परिणाम देता है, इसलिए एक ट्यूपल को वापस करने से काम नहीं होता है। यह संस्करण फ़ंक्शन से स्थिति वापस पास करने के लिए "संदर्भ" तर्क (एक तत्व के साथ सूची) का उपयोग करता है।

मेरे पास एक छोटा संस्करण (103 बाइट्स) है जो स्थिति के लिए एक वैश्विक चर का उपयोग करता है। लेकिन वह केवल पहली कॉल पर काम करेगा। और एक फ़ंक्शन जो केवल एक बार काम करता है वह थोड़ा गड़बड़ लगता है। यकीन नहीं होता कि यह कोड गोल्फ के लिए स्वीकार्य होगा।

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

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

Comments

कार्य अब स्पष्ट रूप से अनुमति दी गई :)

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

@ केल्विन हॉबीज को एक ऐसा नियम मिला, जिसके बारे में मैं आम तौर पर सोच रहा था, लेकिन वह यहां आ सकता है: यदि एक समाधान को एक फ़ंक्शन के रूप में लागू किया जाता है, तो क्या इसका मतलब यह है कि फ़ंक्शन को एक बार में एक से अधिक बार कहा जा सकता है? उदाहरण के लिए, यदि यह एक वैश्विक वैरिएबल का उपयोग करता है जो केवल पहली कॉल पर सही ढंग से आरंभ किया गया है, तो क्या वह गलत होगा ...?

— रेटो कोराडी

@ रिट्रो मैं हां कहूंगा, यह गलत है। फ़ंक्शन को किसी भी संख्या में इसे पुनः स्थापित किए बिना काम करना चाहिए।

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

Answer 11

क्लोजर - 66 बाइट्स

ध्यान दें कि ([] (()) ([] []) [()] [([[] []] [] []) ([] [])])एक मान्य क्लॉज्योर फॉर्म है। इसलिए:

#(letfn[(g[x](apply(if(list? x)+ *)(map g x)))](g(read-string %)))

• यह एक अनाम फ़ंक्शन है जो एक स्ट्रिंग ले रहा है, इसे पढ़ रहा है और इसे दे रहा है g।
• स्थानीय gफ़ंक्शन लागू होते हैं +या इसके तर्कों के उप-तत्वों के *आह्वान के परिणामस्वरूप g।
• पुनरावृत्ति का आधार मामला थोड़ा सूक्ष्म है: यह तब होता है जब xएक खाली क्रम में पहुंच जाता है ; (map g x)रिटर्न nil, applyऑपरेशन के लिए तटस्थ मूल्य देता है।

Answer 12

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

s=>+[...s].reduce((t,c)=>((x=c==']')||c==')'?t[1].push(t.shift().reduce((a,b)=>x?a*b:a+b,+x)):t.unshift([]),t),[[]])