[Python] 중위 -> 후위, 전위 수식 변환, 수식 계산, html 태그 체크

def isHigherOperator(x : str, y : str) -> bool:

    if x not in "+-/*" or y not in "+-/*":

        raise NotOperatorException("isHigherOperator : parameter not operator")

    if x in "*/" and y in "+-" :

        return True

    else:

        return False

class NotOperatorException(Exception):

    pass

class InvalidExpr(Exception):

    pass

def isInt(x) -> bool:

    try:

        int(x)

        return True

    except ValueError:

        return False

def infixToPostfix(expr : str) -> str:

    s = Stack()

    op = "+-*/"

    expr = expr.split()

    prec = {

        "*" : 3, "/" : 3, "+" : 2, "-" : 2, "(" : 1

    }

 

    r = []

 

    for t in expr:

        

        if t == "(":

            s.push(t)

        elif t == ")":

            while True:

                top = s.pop()

                if top == "(":

                    break

                else:

                    r.append(top)

        elif t in op:

            while not s.is_empty() and prec[s.peek()] > prec[t]:

                r.append(s.pop())

            s.push(t)

        else:

            r.append(t)

    

    while not s.is_empty():

        r.append(s.pop())

    

    return " ".join(r)

def reversedExpr(expr : str) -> str:

    expr = expr.split()

    expr.reverse()

    i = 0

    for i in range(len(expr)):

        if expr[i] == '(':

            expr[i] = ')'

        elif expr[i] == ')':

            expr[i] = '('

    return " ".join(expr)

 

def evalPostfix(expr : str):

    alnum = "0123456789"

    expr = expr.split()

    print(expr)

    s = Stack()

    for t in expr:

        if isInt(t):

            s.push(t)

        else :

            a = int(s.pop())

            b = int(s.pop())

            s.push(eval(f"{a} {t} {b}"))

    return s.pop()

def infixToPrefix(expr : str):

    return reversedExpr(infixToPostfix(reversedExpr(expr)))

 

def infixToPrefix_direct(expr : str):

    s = Stack()

    op = "+-*/"

    expr = expr.split()

    prec = {

        "*" : 3, "/" : 3, "+" : 2, "-" : 2, ")" : 1

    }

 

    r = []

 

    for t in expr[::-1]:

        

        if t == ')':

            s.push(t)

        elif t in op:

            while not s.is_empty() and prec[s.peek()] > prec[t]:

                r.insert(0, s.pop())

            s.push(t)

        elif t == '(':

            while True:

                top = s.pop()

                if top == ')':

                    break

                r.insert(0, top)

        else:

            r.insert(0, t)

 

    while not s.is_empty():

        r.insert(0, s.pop())

 

    return " ".join(r)

class TagOpenOrClose(Enum):

    OPEN = 0

    CLOSE = 1

 

class Tag:

    def __init__(self, name : str, openOrClose : TagOpenOrClose) -> None:

        if type(openOrClose) != TagOpenOrClose:

            raise Exception("Tag Init : openOrClose is invalid")

 

        self.__name = name

        self.__openOrClose = openOrClose

 

    def getName(self) -> str:

        return self.__name

    

    def getOpenOrClose(self) -> TagOpenOrClose:

        return self.__openOrClose

    

    def __str__(self) -> str:

        return f"{self.__name}, {self.__openOrClose}"

def htmlTagExtract(html : str) -> list[Tag]:

    q = Queue()

    r = []

    f = False

 

    for ch in html:

        if ch == '<':

            q.enqueue(ch)

            f = True

        elif ch == '>':

            q.enqueue(ch)

            t = ""

            while not q.is_empty():

                t += q.dequeue()

            r.append(t)

            f = False

        elif ( ch.isalpha() or ch == '/' ) and f:

            q.enqueue(ch)

        

    rr = []

    for it in r:

        rr.append(Tag(re.search("\w+", it).group(0), 

            TagOpenOrClose.CLOSE if it.find('/') != -1 else TagOpenOrClose.OPEN))

 

    return rr

def HTMLTagCheck(tags : list[Tag]) -> bool:

    s = Stack()

    i = 0

    while i < len(tags):

        it = tags[i]

        if it.getOpenOrClose() == TagOpenOrClose.OPEN:

            s.push(it)

        else:

            if it.getName() == s.peek().getName() and s.peek().getOpenOrClose() == TagOpenOrClose.OPEN:

                s.pop()

            else:

                break

        i += 1

    

    if not s.is_empty() and i != len(tags):

        return False

    else:

        return True

 

결과 ------------------------------------------------------------------