Check for matching symbols

Question

The following code is a working solution for the balanced parentheses problem.

I'm really just wondering about coding style here when it comes to separating out related if-statements.

When there are two related if-statements, and where the second is run if the first is run, should I merge all checks into one complete if-statement, as in,

if char in open_close_parens and stack and stack[-1] == open_close_parens[char]:

or separate out the two if-statements as I've done here, with the check for an empty stack (list) then being more prominent in the second follow-up if-statement?

 def is_valid(stri: str) -> bool:
    stack = []
    open_close_parens = {
        ')':'(', 
        ']':'[', 
        '}':'{'
    }

    for char in stri:
            if char in open_close_parens:
                # if stack is not empty and there is a match, pop it
                if stack and stack[-1] == open_close_parens[char]:
                    stack.pop()
                else:
                    return False
            else:
                stack.append(char) 

    return not stack

print(is_valid(']'))
print(is_valid('()'))

Answer 1

I would not combine those terms, but there are a few minor improvements.

• Naming: Naming things is hard, but you have some improvements. You should try to use accurate terminology when writing code. You are not checking for parenthesis. You are checking for brackets, where parenthesis () is a special case of brackets.

  Similarly stri is a bad name. Something like brackets is better and because of the typing hint we know it is a string.

  pen_close_parens can be named bracket_pairs and should be a global constant. So BRACKET_PAIRS.

• Early exits and continue: A way to clean up the logic is early exits and continue.

• Tests are nicely placed inside of docstrings.

Code:

BRACKET_PAIRS = {")": "(", "]": "[", "}": "{"}


def balanced_brackets(brackets: str) -> bool:
    """Returns true if the number of brackets are balanced

    >>> balanced_brackets("]")
    False
    >>> balanced_brackets("()")
    True
    """
    stack = []

    for bracket in brackets:
        if bracket not in BRACKET_PAIRS:
            stack.append(bracket)
            continue

        # if stack is not empty and there is a match, pop it
        if not (stack and stack[-1] == BRACKET_PAIRS[bracket]):
            return False

        stack.pop()

    return not stack


if __name__ == "__main__":
    import doctest

    doctest.testmod()

Answer 2

Remember doing this a while back. In my opinion, it is all good. It will work for this problem. The code is nice and easy to read. For small applications, I prefer code as you did with separated if statements, as it is easier to read and understand. Others may not agree, think that it's going to be down to personal preference. Really good points: type hints ;)

Don't know if you noticed but indentation is a bit off in your code, but that probably happened while pasting the code.