Stack Concept and LIFO Principle in DSA Go - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Go stack push/pop sequence?

Consider a stack implemented using a slice in Go. What will be printed after these operations?

DSA Go

package main
import "fmt"
func main() {
    stack := []int{}
    stack = append(stack, 10)
    stack = append(stack, 20)
    stack = append(stack, 30)
    fmt.Print(stack[len(stack)-1], " -> ")
    stack = stack[:len(stack)-1]
    fmt.Print(stack[len(stack)-1], " -> ")
    stack = stack[:len(stack)-1]
    fmt.Print(stack[len(stack)-1], " -> null")
}

A 10 -> 20 -> 30 -> null

B 30 -> 20 -> 10 -> null

C 30 -> 10 -> 20 -> null

D 20 -> 30 -> 10 -> null

💡 Hint

Remember, stack follows Last In First Out (LIFO). The last pushed item is popped first.

The stack after pushes is [10, 20, 30]. The first pop removes 30, printing it. Next pop removes 20, then 10 remains. So output is 30 -> 20 -> 10 -> null.

🧠 Conceptual

intermediate

How many items remain in the stack after these operations?

A stack starts empty. We push 5 items, then pop 3 items. How many items remain in the stack?

A 0

B 3

C 5

D 2

💡 Hint

Each pop removes one item from the stack.

Starting with 0, push 5 items → stack size 5. Pop 3 items → stack size 2 remain.

🔧 Debug

advanced

What error does this Go stack pop code cause?

What error will this code produce when run?

DSA Go

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

A runtime error: slice bounds out of range

B nil pointer dereference

C compilation error: invalid slice operation

D prints empty slice []

💡 Hint

Check what happens when you try to slice beyond zero length.

After popping once, stack length is 0. Trying to pop again slices beyond zero length causing runtime panic: slice bounds out of range.

🚀 Application

advanced

What is the final stack state after these operations?

Starting with an empty stack, perform these operations in order: push 5, push 10, pop, push 15, pop, push 20. What is the stack content from top to bottom?

A 10 -> 5 -> null

B 15 -> 5 -> null

C 20 -> 5 -> null

D 20 -> 15 -> null

💡 Hint

Track each push and pop carefully, remembering LIFO order.

Push 5 → [5]
Push 10 → [5,10]
Pop → removes 10 → [5]
Push 15 → [5,15]
Pop → removes 15 → [5]
Push 20 → [5,20]
Top is 20, then 5.

❓ Predict Output

expert

What is printed by this Go stack reversal code?

This code reverses a stack using another stack. What is the printed output?

DSA Go

package main
import "fmt"
func main() {
    stack := []int{1, 2, 3, 4}
    reversed := []int{}
    for len(stack) > 0 {
        top := stack[len(stack)-1]
        stack = stack[:len(stack)-1]
        reversed = append(reversed, top)
    }
    for i := len(reversed) - 1; i >= 0; i-- {
        fmt.Print(reversed[i], " -> ")
    }
    fmt.Print("null")
}

A 1 -> 2 -> 3 -> 4 -> null

B 4 -> 3 -> 2 -> 1 -> null

C null

D 4 -> 3 -> 2 -> null

💡 Hint

The code pops all items from stack to reversed, then prints reversed in reverse order.

Original stack: [1,2,3,4]
After moving to reversed: [4,3,2,1]
Printing reversed in reverse order prints 1 -> 2 -> 3 -> 4 -> null.

Practice

1. What does the LIFO principle mean in the context of a stack?

easy

A. Last In, First Out - the last element added is the first to be removed

B. Last In, First Out - the first element added is the first to be removed

C. First In, First Out - the first element added is the first to be removed

D. First In, Last Out - the first element added is the last to be removed

Solution

1. Step 1: Understand LIFO meaning

   LIFO stands for Last In, First Out, meaning the last item added to the stack is the first one removed.

2. Step 2: Match with stack behavior

   Stacks follow LIFO, so the last pushed element is popped first.

3. Final Answer:

   Last In, First Out - the last element added is the first to be removed -> Option A

4. Quick Check:

   LIFO = Last In, First Out [OK]

Hint: Remember stack removes newest item first [OK]

Common Mistakes:

• Confusing LIFO with FIFO
• Thinking first added is removed first
• Mixing up stack with queue behavior

2. Which of the following is the correct way to push an element '5' onto a stack named stack in Go?

easy

A. stack.push(5)

B. stack = append(stack, 5)

C. stack.add(5)

D. stack.insert(5)

Solution

1. Step 1: Recall Go slice push syntax

   In Go, stacks are often slices; to push, use append(slice, value).

2. Step 2: Check options for correct syntax

   Only stack = append(stack, 5) correctly adds 5 to the stack slice.

3. Final Answer:

   stack = append(stack, 5) -> Option B

4. Quick Check:

   Go stack push uses append [OK]

Hint: Use append to add elements to Go slices [OK]

Common Mistakes:

• Using non-existent push method on slice
• Using add or insert which are invalid for slices
• Forgetting to assign append result back

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. 30

B. 20

C. 10

D. Error

Solution

1. Step 1: Trace stack push operations

   Elements 10, 20, 30 are pushed in order; stack is [10, 20, 30].

2. Step 2: Pop last element

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

3. Final Answer:

   30 -> Option A

4. Quick Check:

   Last pushed element popped = 30 [OK]

Hint: Last appended element is popped first [OK]

Common Mistakes:

• Printing first element instead of last
• Forgetting to slice stack after pop
• Confusing index for pop operation

4. Identify the error in this Go code that tries to pop an element from a stack:

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

medium

A. Cannot print variable last

B. Syntax error in slice operation

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

D. No error, code runs correctly

Solution

1. Step 1: Check index used for popping

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

2. Step 2: Identify error type

   This causes an index out of range runtime error.

3. Final Answer:

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

4. Quick Check:

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

Hint: Use len(stack)-1 for last index [OK]

Common Mistakes:

• Using len(stack) as index
• Ignoring zero-based indexing
• Assuming code runs without error

5. Given a stack implemented as a slice in Go, how would you reverse the order of elements using only stack operations (push and pop)?

hard

A. Pop elements and discard them to reverse the stack

B. Push elements onto the same stack again without popping

C. Use a queue instead of a stack to reverse elements

D. Pop all elements into a temporary slice, then push them back in order

Solution

1. Step 1: Pop all elements from original stack

   Pop elements one by one and store them in a temporary slice to hold reversed order.

2. Step 2: Push elements back to original stack

   Push elements from temporary slice back to stack; this reverses the order due to LIFO.

3. Final Answer:

   Pop all elements into a temporary slice, then push them back in order -> Option D

4. Quick Check:

   Reversing stack needs pop then push back [OK]

Hint: Pop all, then push back reverses stack [OK]

Common Mistakes:

• Pushing without popping does not reverse
• Discarding elements loses data
• Using queue is not stack operation