Balanced Parentheses Problem Using Stack in DSA Go - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to push an element onto the stack.

DSA Go

stack = []
stack.[1]('(')

Drag options to blanks, or click blank then click option'

Aremove

Bappend

Cpop

Dinsert

Attempts:

3 left

💡 Hint

Common Mistakes

Using pop instead of append will remove an element instead of adding.

Using remove will try to delete a specific element, not add one.

We use append to add an element to the top of the stack.

2fill in blank

medium

Complete the code to check if the stack is empty.

DSA Go

if len(stack) [1] 0:
    print("Stack is empty")

Drag options to blanks, or click blank then click option'

A!=

B>

C<

D==

Attempts:

3 left

💡 Hint

Common Mistakes

Using '>' or '<' will not correctly check for empty stack.

Using '!=' will be true for non-empty stacks.

We check if length equals zero to know if the stack is empty.

3fill in blank

hard

Fix the error in popping the top element from the stack.

DSA Go

top = stack.[1]()

Drag options to blanks, or click blank then click option'

Apop

Bappend

Cremove

Dinsert

Attempts:

3 left

💡 Hint

Common Mistakes

Using append will add an element instead of removing.

Using remove requires a value, not index.

pop() removes and returns the last element from the stack.

4fill in blank

hard

Fill both blanks to check matching parentheses and pop from stack.

DSA Go

if stack and stack[-1] [1] '(':
    stack.[2]()

Drag options to blanks, or click blank then click option'

A==

B!=

Cpop

Dappend

Attempts:

3 left

💡 Hint

Common Mistakes

Using '!=' will check for non-matching which is wrong here.

Using append instead of pop will add elements instead of removing.

We check if top of stack is '(' and then pop it.

5fill in blank

hard

Fill all three blanks to complete the balanced parentheses check loop.

DSA Go

for char in expression:
    if char [1] '(': 
        stack.[2](char)
    elif char [3] ')':
        if not stack:
            return False

Drag options to blanks, or click blank then click option'

A==

Bappend

D!=

Attempts:

3 left

💡 Hint

Common Mistakes

Using '!=' instead of '==' will cause wrong comparisons.

Using pop instead of append when adding '(' will cause errors.

We check if char is '(' to append it, and if char is ')' to check stack.

Practice

1. What is the main purpose of using a stack in the Balanced Parentheses Problem?

easy

A. To keep track of opening parentheses and match them with closing ones

B. To count the total number of parentheses in the string

C. To reverse the string of parentheses

D. To sort the parentheses in order

Solution

1. Step 1: Understand the role of stack in parentheses matching

   The stack stores opening parentheses as they appear to check if each closing parenthesis matches the last opened one. Counting or reversing parentheses does not help in matching pairs correctly; sorting changes the order and breaks the sequence.

2. Final Answer:

   To keep track of opening parentheses and match them with closing ones -> Option A

3. Quick Check:

   Stack usage = matching parentheses [OK]

Hint: Stack stores last opened parenthesis to match closing one [OK]

Common Mistakes:

• Thinking stack counts parentheses instead of matching
• Assuming stack reverses the string
• Believing sorting helps in matching parentheses

2. Which of the following Go code snippets correctly pushes an opening parenthesis '(' onto a stack represented by a slice of runes named stack?

easy

A. stack = append(stack, '(')

B. stack.push('(')

C. stack.add('(')

D. stack.insert('(')

Solution

1. Step 1: Recall how to add elements to a slice in Go

   In Go, slices use the built-in append function to add elements at the end. Since stack is a slice, stack = append(stack, '(') correctly adds '(' to the top.

2. Final Answer:

   stack = append(stack, '(') -> Option A

3. Quick Check:

   Use append to push in Go slices [OK]

Hint: Use append(slice, value) to push in Go [OK]

Common Mistakes:

• Using non-existent methods like push or add on slices
• Forgetting to assign back after append
• Using incorrect method names

3. What will be the output of the following Go code snippet that checks if the string "([])" has balanced parentheses?

func isBalanced(s string) bool {
    stack := []rune{}
    for _, ch := range s {
        if ch == '(' || ch == '[' {
            stack = append(stack, ch)
        } else if ch == ')' {
            if len(stack) == 0 || stack[len(stack)-1] != '(' {
                return false
            }
            stack = stack[:len(stack)-1]
        } else if ch == ']' {
            if len(stack) == 0 || stack[len(stack)-1] != '[' {
                return false
            }
            stack = stack[:len(stack)-1]
        }
    }
    return len(stack) == 0
}

fmt.Println(isBalanced("([])"))

medium

A. runtime error

B. false

C. true

D. compilation error

Solution

1. Step 1: Trace the stack operations for "([])"

   Push '(' then push '['; on encountering ']', pop '['; on encountering ')', pop '('; stack ends empty, so function returns true indicating balanced parentheses.

2. Final Answer:

   true -> Option C

3. Quick Check:

   Stack empty after matching = true [OK]

Hint: Empty stack after processing means balanced [OK]

Common Mistakes:

• Not popping matching opening bracket
• Confusing bracket types
• Ignoring empty stack check before pop

4. Identify the bug in the following Go function that checks balanced parentheses:

func isBalanced(s string) bool {
    stack := []rune{}
    for _, ch := range s {
        if ch == '(' {
            stack = append(stack, ch)
        } else if ch == ')' {
            if len(stack) == 0 || stack[len(stack)-1] != ')' {
                return false
            }
            stack = stack[:len(stack)-1]
        }
    }
    return len(stack) == 0
}

medium

A. Stack is not initialized properly

B. The condition checks for ')' instead of '(' when popping

C. The loop does not iterate over the string

D. The function does not return any value

Solution

1. Step 1: Analyze the popping condition for closing parenthesis

   The code checks if the top of stack is ')', but it should check for '(' to match correctly. Since stack stores '(', checking for ')' fails to match and returns false incorrectly.

2. Final Answer:

   The condition checks for ')' instead of '(' when popping -> Option B

3. Quick Check:

   Match top stack with '(' for ')' closing [OK]

Hint: Match closing bracket with correct opening bracket on stack top [OK]

Common Mistakes:

• Checking wrong character on stack top
• Not handling empty stack before pop
• Ignoring matching pairs logic

5. Given the string "{[()()]()}", which includes curly braces {}, square brackets [], and parentheses (), how should the stack-based algorithm be modified to correctly check for balanced parentheses of all three types?

hard

A. Replace stack with a queue to handle all bracket types

B. Only check for parentheses '()' and ignore other types

C. Use two separate stacks for different bracket types

D. Add conditions to push '{', '[', '(' and pop matching '}', ']', ')' accordingly

Solution

1. Step 1: Extend push logic for all opening brackets

   Push '{', '[', '(' onto the stack when encountered to track all opening brackets. When encountering '}', ']', or ')', check if the top of the stack matches '{', '[', or '(' respectively before popping.

2. Final Answer:

   Add conditions to push '{', '[', '(' and pop matching '}', ']', ')' accordingly -> Option D

3. Quick Check:

   Match all bracket types with stack push/pop [OK]

Hint: Push all openings; pop only if top matches corresponding closing [OK]

Common Mistakes:

• Ignoring curly braces in the algorithm
• Using multiple stacks unnecessarily
• Replacing stack with queue which breaks LIFO logic