leetcode 1106. Parsing A Boolean Expression

Return the result of evaluating a given boolean expression, represented as a string.

An expression can either be:

• "t", evaluating to True;
• "f", evaluating to False;
• "!(expr)", evaluating to the logical NOT of the inner expression expr;
• "&(expr1,expr2,...)", evaluating to the logical AND of 2 or more inner expressions expr1, expr2, ...;
• "|(expr1,expr2,...)", evaluating to the logical OR of 2 or more inner expressions expr1, expr2, ...

 

Example 1:

Input: expression = "!(f)"
Output: true

Example 2:

Input: expression = "|(f,t)"
Output: true

Example 3:

Input: expression = "&(t,f)"
Output: false

Example 4:

Input: expression = "|(&(t,f,t),!(t))"
Output: false

 

Constraints:

• 1 <= expression.length <= 20000
• expression[i] consists of characters in {'(', ')', '&', '|', '!', 't', 'f', ','}.
• expression is a valid expression representing a boolean, as given in the description.

class Solution {
public:
    bool parseBoolExpr(string expression) 
    {
        int pos = 0 ;
        vector<bool> res = brace(expression , pos) ;
        
        if(res.empty()) return false ;
        else return res[0] ;
    }
    
private :
    
    bool expressionRes(char op , vector<bool> &opnds)
    {
        if(opnds.empty()) return false ;
        
        bool res = opnds[0];
        cout<<"primres:"<<res<<endl;
        
        switch(op)
        {
            case '&' :
                for(int i = 1 ; i < opnds.size() ; ++i) res = res & opnds[i] ;
                break ;
            case '|' :
                for(int i = 1 ; i < opnds.size() ; ++i) res = res | opnds[i] ;
                break ;
            case '!' :
                res = !res ;
                break ;
        }
        cout<<"op:"<<op<<"res:"<<res<<endl;
        return res; 
    }
    
    vector<bool> brace(string &expression , int &pos)
    {
        vector<bool> res;
        int len = expression.size() ;
        char op = '.' ;
        
        while(pos < len)
        {
            if(expression[pos] == '(')
            {
                pos++ ;
                vector<bool> suffix = brace(expression , pos) ;
                
                if(suffix.empty()) continue ;
                if(op != '.')
                {
                    res.push_back(expressionRes(op , suffix)) ;
                    op = '.' ;
                }                    
                else
                    res.insert(res.end() , suffix.begin() , suffix.end()) ;

            }
            else if(expression[pos] == ',')
                pos++ ;
            else if(expression[pos] == 't' || expression[pos] == 'f')
            {    
                if(expression[pos] == 't') res.push_back(true) ;
                else res.push_back(false) ;
                pos++ ;
            }
            else if(expression[pos] == ')')
            {
                pos++ ;
                return res ;
            }
            else
            {
                op = expression[pos] ;
                pos++ ;
            }
        }
        
        return res ;
    }
};