Peek Top Element of Stack in DSA Go - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of peeking the top element after these stack operations?

Consider a stack where we push 10, then 20, then 30. We then peek the top element without removing it. What is printed?

DSA Go

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

A Index out of range error

B 30

C 20

D 10

💡 Hint

Remember, peek returns the last pushed element without removing it.

The last element pushed is 30, so peeking returns 30.

❓ Predict Output

intermediate

What happens if you peek an empty stack?

Given an empty stack represented as a slice in Go, what happens if you try to peek the top element using stack[len(stack)-1]?

DSA Go

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

A Prints nil

B Prints 0

C Index out of range runtime panic

D Compilation error

💡 Hint

Think about accessing an element in an empty slice.

Accessing stack[len(stack)-1] when stack is empty causes an index out of range panic.

🧠 Conceptual

advanced

Which statement about peeking the top element of a stack is true?

Select the correct statement about the peek operation on a stack.

A Peek adds a new element to the top of the stack.

B Peek returns the bottom element of the stack.

C Peek removes the top element from the stack and returns it.

D Peek returns the top element without modifying the stack.

💡 Hint

Peek should not change the stack size.

Peek only returns the top element without removing it, so the stack remains unchanged.

🔧 Debug

advanced

Why does this peek implementation cause a runtime error?

Identify the cause of the runtime error in the following Go code that tries to peek the top element of a stack.

DSA Go

package main
import "fmt"
func peek(stack []int) int {
    return stack[0]
}
func main() {
    stack := []int{5, 10, 15}
    fmt.Println(peek(stack))
}

A It returns the bottom element instead of the top element.

B It causes an index out of range error.

C It returns the top element correctly.

D It causes a compilation error due to wrong syntax.

💡 Hint

Remember the top element is the last pushed element, not the first.

The code returns stack[0], which is the bottom element, not the top. It does not cause runtime error but returns wrong element.

🚀 Application

expert

How many elements remain after peeking and popping twice from this stack?

Given a stack with elements [1, 2, 3, 4, 5] (1 is bottom, 5 is top), we peek once, then pop twice. How many elements remain in the stack?

A 3

B 4

C 5

D 2

💡 Hint

Peek does not remove elements, pop removes one element each time.

Peek returns top element without removing it. Two pops remove two elements. Starting with 5 elements, after two pops 3 remain.

Practice

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

easy

A. Returns the top element without removing it

B. Removes the top element from the stack

C. Adds a new element to the top of the stack

D. Checks if the stack is empty

Solution

1. Step 1: Understand stack operations

   A stack stores elements in a last-in, first-out order. Common operations include push (add), pop (remove), and peek (view top).

2. Step 2: Define peek operation

   Peek returns the top element without removing it, allowing you to see the current top without changing the stack.

3. Final Answer:

   Returns the top element without removing it -> Option A

4. Quick Check:

   Peek = View top element without removal [OK]

Hint: Peek shows top without removing it [OK]

Common Mistakes:

• Confusing peek with pop operation
• Thinking peek adds elements
• Assuming peek checks emptiness

2. Which of the following is the correct Go syntax to peek the top element of a stack implemented as a slice named stack?

easy

A. top := stack[len(stack)-1]

B. top := stack[-1]

C. top := stack[0]

D. top := stack[len(stack)]

Solution

1. Step 1: Understand Go slice indexing

   Go slices are zero-indexed. The last element is at index length-1.

2. Step 2: Identify correct top element access

   To peek top, access stack[len(stack)-1]. Using len(stack) is out of range, 0 is bottom, and negative index is invalid.

3. Final Answer:

   top := stack[len(stack)-1] -> Option A

4. Quick Check:

   Last element index = length-1 [OK]

Hint: Use len(stack)-1 to get top index [OK]

Common Mistakes:

• Using len(stack) as index (out of range)
• Using negative index (not supported in Go)
• Accessing stack[0] which is bottom

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

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

medium

A. 10

B. Runtime error

C. 20

D. 30

Solution

1. Step 1: Analyze stack contents

   The stack slice contains elements [10, 20, 30], where 30 is the last element (top).

2. Step 2: Evaluate peek operation

   top := stack[len(stack)-1] accesses stack[2], which is 30, then prints it.

3. Final Answer:

   30 -> Option D

4. Quick Check:

   Top element = 30 [OK]

Hint: Last element is top, printed value is 30 [OK]

Common Mistakes:

• Printing bottom element instead of top
• Indexing out of range causing error
• Confusing output with pop operation

4. Identify the error in the following Go code that tries to peek the top element of a stack:

stack := []int{}
top := stack[len(stack)-1]
fmt.Println(top)

medium

A. Syntax error due to missing import

B. Index out of range runtime error

C. top will be zero by default

D. Code runs fine and prints 0

Solution

1. Step 1: Check stack initialization

   The stack is initialized as an empty slice with length 0.

2. Step 2: Analyze peek operation

   Accessing stack[len(stack)-1] means stack[-1], which is invalid and causes runtime panic: index out of range.

3. Final Answer:

   Index out of range runtime error -> Option B

4. Quick Check:

   Empty slice peek causes runtime error [OK]

Hint: Empty stack peek causes index error [OK]

Common Mistakes:

• Assuming peek returns zero on empty stack
• Ignoring runtime panic possibility
• Confusing syntax error with runtime error

5. Given a stack implemented as a slice stack := []int{5, 10, 15}, write the correct Go code snippet to safely peek the top element and handle the case when the stack is empty.

hard

A. top := stack[0]
fmt.Println(top)

B. top := stack[len(stack)]
fmt.Println(top)

C. if len(stack) > 0 {
top := stack[len(stack)-1]
fmt.Println(top)
} else {
fmt.Println("Stack is empty")
}

D. if stack != nil {
top := stack[len(stack)-1]
fmt.Println(top)
}

Solution

1. Step 1: Check stack length before peeking

   To avoid runtime error, verify stack length > 0 before accessing top element.

2. Step 2: Access top element safely and handle empty case

   If stack is not empty, peek top with stack[len(stack)-1]. Otherwise, print "Stack is empty" message.

3. Final Answer:

   if len(stack) > 0 { top := stack[len(stack)-1] fmt.Println(top) } else { fmt.Println("Stack is empty") } -> Option C

4. Quick Check:

   Check length before peek to avoid errors [OK]

Hint: Check length > 0 before peek [OK]

Common Mistakes:

• Not checking length before peek
• Using len(stack) as index
• Assuming nil check is enough