Why Stack Exists and What Problems It Solves in DSA Go - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why do we use a stack in function calls?

Imagine you are baking cookies and following a recipe step by step. Why is a stack useful when a computer runs functions that call other functions?

A Because a stack keeps track of the order to return from each function, like remembering which recipe step to go back to next.

B Because a stack stores all the ingredients needed for the recipe at once.

C Because a stack sorts the functions alphabetically before running them.

D Because a stack deletes all previous functions before running a new one.

💡 Hint

Think about how you remember where you left off when you pause a task and start another.

A stack helps the computer remember the order of function calls so it can return to the right place after finishing each function. This is like putting tasks on a stack and finishing the last one first.

❓ Predict Output

intermediate

Output of Stack Operations

What is the printed state of the stack after these operations?

DSA Go

stack := []int{}
stack = append(stack, 10) // push 10
stack = append(stack, 20) // push 20
stack = stack[:len(stack)-1] // pop
stack = append(stack, 30) // push 30
fmt.Println(stack)

A [20 30]

B [10 20 30]

C [10 30]

D [10]

💡 Hint

Remember that pop removes the last pushed item.

We push 10, then 20. Popping removes 20. Then pushing 30 adds it on top. So the stack has 10 and 30.

🔧 Debug

advanced

Why does this stack code cause an error?

Look at this Go code for popping from a stack. Why does it cause a runtime error?

DSA Go

stack := []int{}
stack = append(stack, 5)
stack = stack[:len(stack)-1]
stack = stack[:len(stack)-1] // error here
fmt.Println(stack)

A Because fmt.Println cannot print slices.

B Because append is used incorrectly with pop operations.

C Because the stack is not initialized properly.

D Because popping from an empty stack causes a slice bounds out of range error.

💡 Hint

Think about what happens if you remove more items than exist.

After popping once, the stack is empty. Trying to pop again reduces length below zero, causing a runtime error.

🚀 Application

advanced

Using Stack to Reverse a String

Which code snippet correctly uses a stack to reverse the string "hello"?

A

stack := []rune{}
for _, ch := range "hello" {
  stack = append([]rune{ch}, stack...)
}
fmt.Println(string(stack))

B

stack := []rune{}
for _, ch := range "hello" {
  stack = append(stack, ch)
}
result := []rune{}
for len(stack) > 0 {
  result = append(result, stack[len(stack)-1])
  stack = stack[:len(stack)-1]
}
fmt.Println(string(result))

C

stack := []rune{}
for _, ch := range "hello" {
  stack = append(stack, ch)
}
fmt.Println(string(stack))

D

stack := []rune{}
for _, ch := range "hello" {
  stack = append(stack, ch)
}
result := []rune{}
for i := 0; i < len(stack); i++ {
  result = append(result, stack[i])
}
fmt.Println(string(result))

💡 Hint

Think about how popping from a stack reverses order.

Option B pushes all characters, then pops them to reverse the string. Others either do not reverse or use inefficient methods.

🧠 Conceptual

expert

Why is stack preferred for undo operations?

In text editors, undo actions are often implemented using a stack. Why is a stack the best choice for this?

A Because the last action done should be the first one undone, matching the last-in, first-out behavior of a stack.

B Because a stack automatically merges similar actions together.

C Because a stack can store all actions sorted by their type.

D Because a stack deletes all previous actions when a new action is done.

💡 Hint

Think about which action you want to undo first.

Undoing requires reversing the order of actions. The last action done should be undone first, which fits the stack's last-in, first-out rule.

Practice

1. Why do we use a stack data structure in programming?

easy

A. To sort numbers in ascending order automatically

B. To store data in random order for quick access

C. To keep track of function calls and return in the correct order

D. To store data permanently on disk

Solution

1. Step 1: Understand the role of stack in function calls

   Stacks help keep track of which function called which, so the program can return to the right place after finishing a function.

2. Step 2: Recognize the order of operations in stacks

   Stacks follow Last In First Out (LIFO), which matches how function calls return in reverse order.

3. Final Answer:

   To keep track of function calls and return in the correct order -> Option C

4. Quick Check:

   Stack = function call tracking [OK]

Hint: Stack tracks last function called first returned [OK]

Common Mistakes:

• Thinking stack stores data randomly
• Confusing stack with sorting
• Assuming stack stores data permanently

2. Which of the following is the correct way to push an element onto a stack in Go using a slice?

easy

A. stack = append(stack, element)

B. stack.push(element)

C. stack.add(element)

D. stack.insert(element)

Solution

1. Step 1: Recall how slices work in Go

   In Go, slices can be appended using the built-in append function.

2. Step 2: Identify the correct syntax for adding to stack

   Since stack is a slice, adding an element is done by stack = append(stack, element).

3. Final Answer:

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

4. Quick Check:

   Go slice append = push stack [OK]

Hint: Use append() to add element to slice stack [OK]

Common Mistakes:

• Using non-existent push method on slice
• Using add or insert which are not Go slice methods
• Forgetting to assign back to stack after append

3. What will be the output of the following Go code snippet?

stack := []int{}
stack = append(stack, 10)
stack = append(stack, 20)
stack = append(stack, 30)
last := stack[len(stack)-1]
stack = stack[:len(stack)-1]
fmt.Println(last)

medium

A. 10

B. 30

C. Error

D. 20

Solution

1. Step 1: Trace the stack after each append

   After appending 10, 20, 30, stack = [10, 20, 30].

2. Step 2: Identify the last element and remove it

   last = stack[len(stack)-1] = 30; then stack is sliced to remove last element.

3. Final Answer:

   30 -> Option B

4. Quick Check:

   Last pushed = 30 popped = 30 [OK]

Hint: Last appended element is popped and printed [OK]

Common Mistakes:

• Printing first element instead of last
• Confusing slice indexing
• Expecting error due to slicing

4. Find the error in this Go code that tries to pop an element from a stack represented by a slice:

stack := []int{1, 2, 3}
last := stack[len(stack)]
stack = stack[:len(stack)-1]
fmt.Println(last)

medium

A. Index out of range error when accessing stack[len(stack)]

B. Syntax error in slice operation

C. No error, code works fine

D. Stack slice is empty before pop

Solution

1. Step 1: Check indexing used to get last element

   stack[len(stack)] tries to access index equal to length, which is out of range (indexes go from 0 to len-1).

2. Step 2: Confirm correct index for last element

   The last element is at stack[len(stack)-1], so the code causes runtime error.

3. Final Answer:

   Index out of range error when accessing stack[len(stack)] -> Option A

4. Quick Check:

   Indexing error = Index out of range error when accessing stack[len(stack)] [OK]

Hint: Last element index is length-1, not length [OK]

Common Mistakes:

• Using len(stack) as index instead of len(stack)-1
• Assuming slice indexing starts at 1
• Ignoring runtime errors

5. You want to reverse a string using a stack in Go. Which approach correctly uses a stack to reverse the string "hello"?

hard

A. Sort characters alphabetically to reverse string

B. Append characters directly to a new string without stack

C. Use a queue to store characters and dequeue to reverse

D. Push each character onto a stack, then pop all to build reversed string

Solution

1. Step 1: Understand stack's LIFO property for reversing

   Pushing characters in order and popping reverses their order.

2. Step 2: Identify correct method to reverse string using stack

   Push all chars, then pop to build reversed string matches stack usage.

3. Final Answer:

   Push each character onto a stack, then pop all to build reversed string -> Option D

4. Quick Check:

   Stack LIFO reverses string [OK]

Hint: Stack reverses order by popping last pushed first [OK]

Common Mistakes:

• Using queue which reverses differently
• Appending without stack does not use stack concept
• Sorting changes order, not reverses