Balanced Parentheses Problem Using Stack in DSA Go - Build from Scratch

Balanced Parentheses Problem Using Stack

📖 Scenario: Imagine you are building a simple code editor that checks if the parentheses in a line of code are balanced. Balanced parentheses mean every opening bracket '(' has a matching closing bracket ')'. This helps avoid syntax errors.

🎯 Goal: You will create a program that uses a stack to check if a given string of parentheses is balanced or not.

📋 What You'll Learn

Create a stack using a slice of runes

Use a variable to hold the input string of parentheses

Write logic to push and pop from the stack to check balance

Print "Balanced" if parentheses match, else "Not Balanced"

💡 Why This Matters

🌍 Real World

Checking balanced parentheses is important in compilers, code editors, and calculators to ensure expressions are valid.

💼 Career

Understanding stacks and balanced parentheses is a common interview question and fundamental for parsing tasks in software development.

1

Create the input string of parentheses

Create a variable called input and set it to the string "(()())".

DSA Go

# Create a variable called input and set it to "(()())"
# Your code here

Hint

Use input := "(()())" to create the string variable.

2

Create an empty stack to hold runes

Create a variable called stack as an empty slice of runes: var stack []rune.

DSA Go

package main

func main() {
    input := "(()())"
    // Create an empty stack of runes
    // Your code here
}

Hint

Use var stack []rune to declare an empty stack.

3

Check parentheses balance using the stack

Write a for loop using for _, ch := range input to iterate over each character in input. Inside the loop, if ch == '(', append it to stack. If ch == ')', check if stack is empty; if empty, print "Not Balanced" and return. Otherwise, pop the last element from stack.

DSA Go

package main

import "fmt"

func main() {
    input := "(()())"
    var stack []rune
    // Loop over input and use stack to check balance
    // Your code here
}

Hint

Use a loop to check each character. Push '(' to stack, pop when ')' found. If stack empty when popping, print "Not Balanced" and stop.

4

Print the final result after checking all parentheses

After the loop, check if len(stack) == 0. If yes, print "Balanced". Otherwise, print "Not Balanced".

DSA Go

package main

import "fmt"

func main() {
    input := "(()())"
    var stack []rune

    for _, ch := range input {
        if ch == '(' {
            stack = append(stack, ch)
        } else if ch == ')' {
            if len(stack) == 0 {
                fmt.Println("Not Balanced")
                return
            }
            stack = stack[:len(stack)-1]
        }
    }
    // Print "Balanced" if stack is empty, else "Not Balanced"
    // Your code here
}

Hint

After the loop, if stack is empty, print "Balanced"; otherwise, print "Not Balanced".

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