leetcode：736. LISP syntax parsing [flowery + stack + status enumaotu + slots]

analysis

Look at knowledge without logic

Enum + auto

Setting up id The state of , It can be understood as “ Static state variables of class ”
Used to judge and identify unique States , You can use is Judge

solts

About solts Usage of , It can also be understood as “ Static variable of class ”


Once a class is modified , The value of all instances will change

ac code

from enum import Enum, auto

class ExprStatus(Enum):
    VALUE = auto()  #  The initial state 
    NONE  = auto()  #  Unknown expression type 
    LET   = auto()  # let  expression 
    LET1  = auto()  # let  The expression has been parsed  vi  Variable 
    LET2  = auto()  # let  The expression has parsed the last expression  expr
    ADD   = auto()  # add  expression 
    ADD1  = auto()  # add  The expression has been parsed  e1  expression 
    ADD2  = auto()  # add  The expression has been parsed  e2  expression 
    MULT  = auto()  # mult  expression 
    MULT1 = auto()  # mult  The expression has been parsed  e1  expression 
    MULT2 = auto()  # mult  The expression has been parsed  e2  expression 
    DONE  = auto()  #  Parsing complete 

class Expr:
    #__slots__ = 'status', 'var', 'value', 'e1', 'e2'

    def __init__(self, status):
        self.status = status
        self.var = ''  # let  The variable of  vi
        self.value = 0  # VALUE  The number of States , perhaps  LET2  The value of the last expression of the state 
        self.e1 = self.e2 = 0  # add  or  mult  Two expressions of expression  e1  and  e2  The numerical 

class Solution:
    def evaluate(self, expression: str) -> int:
        scope = defaultdict(list)

        def calculateToken(token: str) -> int:
            return scope[token][-1] if token[0].islower() else int(token)

        vars = []
        s = []
        cur = Expr(ExprStatus.VALUE)
        i, n = 0, len(expression)
        while i < n:
            if expression[i] == ' ':
                i += 1  #  Remove space 
                continue
            if expression[i] == '(':
                i += 1  #  Remove the left parenthesis 
                s.append(cur)
                cur = Expr(ExprStatus.NONE)
                continue
            if expression[i] == ')':  #  In essence, it turns the expression into a  token
                i += 1  #  Remove the closing bracket 
                if cur.status is ExprStatus.LET2:
                    token = str(cur.value)
                    for var in vars[-1]:
                        scope[var].pop()  #  Clear scope 
                    vars.pop()
                elif cur.status is ExprStatus.ADD2:
                    token = str(cur.e1 + cur.e2)
                else:
                    token = str(cur.e1 * cur.e2)
                cur = s.pop()  #  Get the upper level status 
            else:
                i0 = i
                while i < n and expression[i] != ' ' and expression[i] != ')':
                    i += 1
                token = expression[i0:i]

            if cur.status is ExprStatus.VALUE:
                cur.value = int(token)
                cur.status = ExprStatus.DONE
            elif cur.status is ExprStatus.NONE:
                if token == "let":
                    cur.status = ExprStatus.LET
                    vars.append([])  #  Record all variables in the scope of this layer ,  Convenient for subsequent removal 
                elif token == "add":
                    cur.status = ExprStatus.ADD
                elif token == "mult":
                    cur.status = ExprStatus.MULT
            elif cur.status is ExprStatus.LET:
                if expression[i] == ')':  # let  The last of the expression  expr  expression 
                    cur.value = calculateToken(token)
                    cur.status = ExprStatus.LET2
                else:
                    cur.var = token
                    vars[-1].append(token)  #  Record all variables in the scope of this layer ,  Convenient for subsequent removal 
                    cur.status = ExprStatus.LET1
            elif cur.status is ExprStatus.LET1:
                scope[cur.var].append(calculateToken(token))
                cur.status = ExprStatus.LET
            elif cur.status is ExprStatus.ADD:
                cur.e1 = calculateToken(token)
                cur.status = ExprStatus.ADD1
            elif cur.status is ExprStatus.ADD1:
                cur.e2 = calculateToken(token)
                cur.status = ExprStatus.ADD2
            elif cur.status is ExprStatus.MULT:
                cur.e1 = calculateToken(token)
                cur.status = ExprStatus.MULT1
            elif cur.status is ExprStatus.MULT1:
                cur.e2 = calculateToken(token)
                cur.status = ExprStatus.MULT2
        return cur.value

summary

After a few months
I also found a daily problem that I don't even want to see the solution
nice