Stacks: Balanced Brackets

A bracket is considered to be any one of the following characters: (, ), {, }, [, or ].

Two brackets are considered to be a matched pair if the an opening bracket (i.e., (, [, or {) occurs to the left of a closing bracket (i.e., ), ], or }) of the exact same type. There are three types of matched pairs of brackets: [], {}, and ().

A matching pair of brackets is not balanced if the set of brackets it encloses are not matched. For example, {[(])} is not balanced because the contents in between { and } are not balanced. The pair of square brackets encloses a single, unbalanced opening bracket, (, and the pair of parentheses encloses a single, unbalanced closing square bracket, ].

Some examples of balanced brackets are []{}(), [({})]{}() and ({(){}[]})[].

By this logic, we say a sequence of brackets is considered to be balanced if the following conditions are met:

• It contains no unmatched brackets.
• The subset of brackets enclosed within the confines of a matched pair of brackets is also a matched pair of brackets.

Given strings of brackets, determine whether each sequence of brackets is balanced. If a string is balanced, print YES on a new line; otherwise, print NO on a new line.

Input Format

The first line contains a single integer, $n$, denoting the number of strings.

Each line $i$ of the $n$ subsequent lines consists of a single string, $s$, denoting a sequence of brackets.

Constraints

• $1 \le n \le 10^3$

• $1 \le length(s) \le 10^3$, where $length(s)$ is the length of the sequence.

• Each character in the sequence will be a bracket (i.e., {, }, (, ), [, and ]).

Output Format

For each string, print whether or not the string of brackets is balanced on a new line. If the brackets are balanced, print YES; otherwise, print NO.

Sample Input

3
{[()]}
{[(])}
{{[[(())]]}}

Sample Output

YES
NO
YES

My Answer Code

def is_matched(expression):
    
    if len(expression) % 2 == 1:
        return False

    open_brackets = ['{', '(', '[']
    closing_brackets = ['}', ')', ']']
    bracket_sets = dict(zip(open_brackets, closing_brackets))

    open_b = []
    for i in range(len(expression)):
        if expression[i] in open_brackets:
            open_b.append(expression[i])

        else:
            if bracket_sets[open_b.pop()] != expression[i]:
                return False
            
    return True

Test Code

t = int(input().strip())

for _ in range(t):
    expression = input().strip()
    if is_matched(expression) == True:
        print("YES")
    else:
        print("NO")

 3
 ({[]})
YES
 {[}]
NO
 {[(((())))]}
YES