Balanced Parentheses Problem Using Stack in DSA Python - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Balanced Parentheses Check

What is the output of the following code when checking the string "{[()]}" for balanced parentheses?

DSA Python

def is_balanced(s):
    stack = []
    pairs = {')': '(', ']': '[', '}': '{'}
    for char in s:
        if char in '([{' :
            stack.append(char)
        elif char in ')]}' :
            if not stack or stack.pop() != pairs[char]:
                return False
    return not stack

print(is_balanced("{[()]}") )

A True

B False

C SyntaxError

D None

💡 Hint

Think about how the stack is used to match opening and closing brackets.

The code uses a stack to push opening brackets and pops when a matching closing bracket is found. The string "{[()]}" is perfectly balanced, so the function returns True.

❓ Predict Output

intermediate

Output for Unbalanced Parentheses

What will the function return when checking the string "{[(])}" for balanced parentheses?

DSA Python

def is_balanced(s):
    stack = []
    pairs = {')': '(', ']': '[', '}': '{'}
    for char in s:
        if char in '([{' :
            stack.append(char)
        elif char in ')]}' :
            if not stack or stack.pop() != pairs[char]:
                return False
    return not stack

print(is_balanced("{[(])}") )

A False

B None

C IndexError

D True

💡 Hint

Check if the order of brackets is correct in the string.

The string "{[(])}" has mismatched brackets: the closing bracket ")" does not match the last opening bracket "[". So the function returns False.

🔧 Debug

advanced

Identify the Error in Parentheses Checking Code

What error will this code produce when run with input ")()[]{}"?

DSA Python

def check_balanced(s):
    stack = []
    pairs = {')': '(', ']': '[', '}': '{'}
    for char in s:
        if char in '([{' :
            stack.append(char)
        elif char in ')]}' :
            if stack.pop() != pairs[char]:
                return False
    return not stack

print(check_balanced(")()[]{}"))

A False

B TypeError

C True

D IndexError

💡 Hint

What happens if you pop from an empty stack?

The code does not check if the stack is empty before popping. When a closing bracket appears but the stack is empty, pop() causes an IndexError.

❓ Predict Output

advanced

Output of Balanced Parentheses with Extra Characters

What is the output of the code when checking the string "a+(b*c)-{d/e}" for balanced parentheses?

DSA Python

def is_balanced(s):
    stack = []
    pairs = {')': '(', ']': '[', '}': '{'}
    for char in s:
        if char in '([{' :
            stack.append(char)
        elif char in ')]}' :
            if not stack or stack.pop() != pairs[char]:
                return False
    return not stack

print(is_balanced("a+(b*c)-{d/e}"))

A SyntaxError

B False

C True

D None

💡 Hint

Ignore characters that are not brackets.

The function ignores non-bracket characters and correctly matches all brackets in the string, so it returns True.

🧠 Conceptual

expert

Stack Usage in Balanced Parentheses Algorithm

Why is a stack the best data structure to check for balanced parentheses in a string?

A Because a stack automatically removes all brackets when a closing bracket is found.

B Because a stack allows checking the most recent opening bracket first, matching the last opened with the first closed.

C Because a stack stores all brackets and sorts them alphabetically for easy matching.

D Because a stack can store the count of brackets without tracking their order.

💡 Hint

Think about the order in which brackets must be matched.

A stack follows Last-In-First-Out order, which matches the requirement to pair the most recent opening bracket with the next closing bracket.