पायथन में एक बूलियन अभिव्यक्ति को पार्स करना

मान लीजिए कि हमारे पास एक बूलियन अभिव्यक्ति है, हमें उस अभिव्यक्ति का मूल्यांकन करने के बाद परिणाम खोजना होगा।

एक व्यंजक या तो हो सकता है -

• "t", ट्रू का मूल्यांकन;

• "f", असत्य का मूल्यांकन करना;

• "!(अभिव्यक्ति)", आंतरिक अभिव्यक्ति के तार्किक नहीं का मूल्यांकन;

• "&(expr1,expr2,...)", तार्किक और 2 या अधिक आंतरिक अभिव्यक्तियों का मूल्यांकन;

• "|(expr1,expr2,...)", तार्किक या 2 या अधिक आंतरिक अभिव्यक्तियों का मूल्यांकन;

इसलिए, यदि इनपुट "|(!(t),&(t,f,t))" जैसा है, तो आउटपुट fasle होगा, ऐसा इसलिए है क्योंकि !(t) गलत है, तब &(t,f, t) भी गलत है, इसलिए OR सभी झूठे मान झूठे होंगे।

इसे हल करने के लिए, हम इन चरणों का पालन करेंगे -

• हल () को परिभाषित करें, इसमें ई, i

  लगेगा

• अगर e[i] "f" के समान है, तो -

  • वापसी (गलत, मैं + 1)

• अन्यथा जब e[i] "t" के समान हो -

• वापसी (सच, मैं + 1)

• op :=e[i], i :=i + 2

• एक स्टैक परिभाषित करें

• जबकि e[i] कोष्ठक बंद नहीं कर रहा है, −

  . करें

  • अगर e[i] "," के समान है, तो -

    • मैं :=मैं + 1

    • निम्नलिखित भाग पर ध्यान न दें, अगले पुनरावृत्ति पर जाएं

  • रेस, आई:=हल करें (ई, आई)

  • रेस को स्टैक में पुश करें

• यदि op "&" के समान है, तो -

  • जब स्टैक में सभी तत्व सत्य होते हैं, अन्यथा गलत, i + 1

• अन्यथा जब op "OR" के समान हो -

  • जब स्टैक में कम से कम एक तत्व सत्य हो, अन्यथा असत्य, i + 1

• वापसी (ढेर के विपरीत [0], i + 1)

• मुख्य विधि से, निम्न कार्य करें -

• एस, वाई:=हल (अभिव्यक्ति, 0)

• वापसी एस

आइए बेहतर समझ पाने के लिए निम्नलिखित कार्यान्वयन देखें -

उदाहरण

class Solution(object):
   def parseBoolExpr(self, expression):
      s,y = self.solve(expression,0)
      return s
   def solve(self,e,i):
      if e[i] =="f":
         return False,i+1
      elif e[i] == "t":
         return True,i+1
      op = e[i]
      i = i+2
      stack = []
      while e[i]!=")":
         if e[i] == ",":
            i+=1
            continue
         res,i = self.solve(e,i)
         stack.append(res)
      if op == "&":
         return all(stack),i+1
      elif op == "|":
         return any(stack),i+1
      return not stack[0],i+1
ob = Solution()
print(ob.parseBoolExpr("|(!(t),&(t,f,t))"))

इनपुट

"|(!(t),&(t,f,t))"

आउटपुट

False