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

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

एक अभिव्यक्ति या तो हो सकती है:

• "t", जो True का मूल्यांकन करती है;
• "f", जो False का मूल्यांकन करती है;
• "!(expression)", जो आंतरिक अभिव्यक्ति का तार्किक NOT है;
• "&(expr1,expr2,...)", जो 2 या अधिक आंतरिक अभिव्यक्तियों का तार्किक AND है;
• "|(expr1,expr2,...)", जो 2 या अधिक आंतरिक अभिव्यक्तियों का तार्किक OR है;

उदाहरण के लिए, यदि इनपुट "|(!(t),&(t,f,t))" है, तो आउटपुट false होगा, क्योंकि !(t) false है, फिर &(t,f,t) भी false है, इसलिए सभी false मानों का OR false होगा।

हल करने के चरण

• solve() परिभाषित करें, यह e, i लेगा
  • यदि e[i] "f" के बराबर है, तो:
    • (False, i + 1) वापस करें
  • अन्यथा जब e[i] "t" के बराबर है:
    • (True, i + 1) वापस करें
  • op := e[i], i := i + 2
  • एक स्टैक परिभाषित करें
  • जब तक e[i] क्लोजिंग पैरेंथेसिस नहीं है:
    • यदि e[i] "," के बराबर है, तो:
      • i := i + 1
      • निम्न भाग को अनदेखा करें, अगले पुनरावृत्ति पर जाएं
    • res, i := solve(e, i)
    • res को स्टैक में डालें
  • यदि op "&" के बराबर है, तो:
    • सत्य वापस करें जब स्टैक में सभी तत्व सत्य हों, अन्यथा असत्य, i + 1
  • अन्यथा जब op "|" के बराबर है:
    • सत्य वापस करें जब स्टैक में कम से कम एक तत्व सत्य हो, अन्यथा असत्य, i + 1
  • (stack[0] का व्युत्क्रम, i + 1) वापस करें
• मुख्य मेथड से, निम्न करें:
  • s, y := solve(expression, 0)
  • s वापस करें

उदाहरण

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