Pop Operation on Stack in DSA Go - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output after popping from the stack?

Consider a stack implemented as a slice in Go. What will be the printed stack after popping one element?

DSA Go

package main
import "fmt"
func main() {
    stack := []int{10, 20, 30, 40}
    stack = stack[:len(stack)-1] // pop operation
    fmt.Println(stack)
}

A [10 20 30]

B [10 20 30 40]

C [20 30 40]

D []

💡 Hint

Remember that popping removes the last element from the stack.

The pop operation removes the last element (40) from the stack, leaving [10 20 30].

❓ Predict Output

intermediate

What happens if you pop from an empty stack?

What will happen when the following Go code runs?

DSA Go

package main
import "fmt"
func main() {
    stack := []int{}
    stack = stack[:len(stack)-1] // pop operation
    fmt.Println(stack)
}

A []

B panic: runtime error: slice bounds out of range

C [0]

D [nil]

💡 Hint

Think about what happens when you try to slice with a negative index.

Since the stack is empty, len(stack) is 0, so len(stack)-1 is -1, causing a runtime panic due to invalid slice bounds.

🔧 Debug

advanced

Identify the error in this pop implementation

What error will this Go code produce when popping from the stack?

DSA Go

package main
import "fmt"
func pop(stack []int) ([]int, int) {
    val := stack[len(stack)-1]
    stack = stack[:len(stack)-1]
    return stack, val
}
func main() {
    stack := []int{1, 2, 3}
    stack, val := pop(stack)
    fmt.Println(stack, val)
}

A compilation error

B panic: runtime error: index out of range

C [1 2 3] 0

D [1 2] 3

💡 Hint

Check the index used to access the last element.

The code tries to access stack[len(stack)], but valid indices go up to len(stack)-1, causing an index out of range panic.

🧠 Conceptual

advanced

What is the time complexity of pop operation on a stack implemented with a slice?

Consider a stack implemented as a slice in Go. What is the time complexity of the pop operation?

A O(log n) - logarithmic time

B O(n) - linear time

C O(1) - constant time

D O(n^2) - quadratic time

💡 Hint

Popping removes the last element without shifting others.

Popping from the end of a slice is done by slicing, which is a constant time operation.

🚀 Application

expert

After a sequence of push and pop operations, what is the final stack?

Given the following operations on an empty stack, what is the final stack printed? Operations: - push 5 - push 10 - pop - push 15 - pop - push 20 Code snippet: package main import "fmt" func main() { stack := []int{} stack = append(stack, 5) stack = append(stack, 10) stack = stack[:len(stack)-1] // pop stack = append(stack, 15) stack = stack[:len(stack)-1] // pop stack = append(stack, 20) fmt.Println(stack) }

A [5 20]

B [5 10 15 20]

C [20]

D [5 15 20]

💡 Hint

Track the stack after each operation carefully.

After pushing 5 and 10, stack is [5 10]. Pop removes 10 → [5]. Push 15 → [5 15]. Pop removes 15 → [5]. Push 20 → [5 20].

Practice

1. What does the pop operation do in a stack?

easy

A. Clears all elements from the stack

B. Adds an element to the bottom of the stack

C. Returns the bottom element without removing it

D. Removes and returns the top element of the stack

Solution

1. Step 1: Understand stack behavior

   A stack follows Last In First Out (LIFO) principle, so the last added element is removed first.

2. Step 2: Define pop operation

   The pop operation removes and returns the top element of the stack, which is the last inserted item.

3. Final Answer:

   Removes and returns the top element of the stack -> Option D

4. Quick Check:

   Pop = remove top element [OK]

Hint: Pop always removes the last added item from the stack [OK]

Common Mistakes:

• Thinking pop removes from bottom
• Confusing pop with peek
• Assuming pop clears the stack

2. Which of the following is the correct Go syntax to pop an element from a stack represented as a slice named stack?

easy

A. element := stack[0]; stack = stack[1:]

B. element := stack[len(stack)-1]; stack = stack[:len(stack)-1]

C. element := stack[len(stack)]; stack = stack[:len(stack)-1]

D. element := stack[len(stack)-1]; stack = stack[1:]

Solution

1. Step 1: Identify top element index in slice

   In Go, the top of the stack is the last element: index len(stack)-1.

2. Step 2: Correctly slice to remove top element

   To pop, get element at len(stack)-1, then slice stack up to len(stack)-1 to remove it.

3. Final Answer:

   element := stack[len(stack)-1]; stack = stack[:len(stack)-1] -> Option B

4. Quick Check:

   Pop syntax = element last, slice off last [OK]

Hint: Pop last element with slice[:len(slice)-1] [OK]

Common Mistakes:

• Using index len(stack) which is out of range
• Removing from front instead of end
• Not updating the stack slice after pop

3. What is the output of the following Go code?

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

medium

A. 30
[10 20]

B. 20
[10 20 30]

C. 30
[10 20 30]

D. 10
[20 30]

Solution

1. Step 1: Identify popped element

   element = stack[len(stack)-1] = stack[2] = 30

2. Step 2: Update stack after pop

   stack = stack[:2] = [10, 20]

3. Final Answer:

   30 [10 20] -> Option A

4. Quick Check:

   Pop returns 30, stack left [10 20] [OK]

Hint: Pop returns last element, stack shrinks by one [OK]

Common Mistakes:

• Printing old stack without slicing
• Confusing index for popped element
• Not updating stack slice after pop

4. Consider this Go code snippet for popping from a stack:

stack := []int{5, 15, 25}
element := stack[len(stack)]
stack = stack[:len(stack)-1]
fmt.Println(element)

What is the error in this code?

medium

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

B. Stack slice is not updated correctly after pop

C. Variable element is not declared

D. No error, code runs fine

Solution

1. Step 1: Check index used for popping

   Accessing stack[len(stack)] is invalid because slice indices go from 0 to len(stack)-1.

2. Step 2: Identify runtime error

   This causes an index out of range runtime error when trying to access stack[len(stack)].

3. Final Answer:

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

4. Quick Check:

   Index must be len(stack)-1, not len(stack) [OK]

Hint: Slice indices max at len(slice)-1, not len(slice) [OK]

Common Mistakes:

• Using len(stack) as index
• Ignoring runtime errors
• Assuming slice indexing is inclusive of len

5. You have a stack implemented as a slice in Go: stack := []int{1, 2, 3, 4, 5}. You want to pop two elements and then push 10 and 20. What will be the final stack?

hard

A. [10 20]

B. [1 2 3 4 5 10 20]

C. [1 2 3 10 20]

D. [1 2 10 20]

Solution

1. Step 1: Pop two elements from stack

   Pop removes last two elements: 5 and 4. Stack becomes [1, 2, 3].

2. Step 2: Push 10 and 20 onto stack

   Appending 10 and 20 results in [1, 2, 3, 10, 20].

3. Final Answer:

   [1 2 3 10 20] -> Option C

4. Quick Check:

   Pop twice, then push twice = [1 2 3 10 20] [OK]

Hint: Pop removes last; push adds at end [OK]

Common Mistakes:

• Not popping twice before pushing
• Appending instead of replacing popped elements
• Confusing order of push and pop