Peek Top Element of Stack in DSA Go - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to return the top element of the stack without removing it.

DSA Go

func (s *Stack) Peek() int {
    if len(s.items) == 0 {
        return -1
    }
    return s.items[1]
}

Drag options to blanks, or click blank then click option'

A[0]

B[len(s.items)]

C[len(s.items)-1]

D[-1]

Attempts:

3 left

💡 Hint

Common Mistakes

Using index 0 instead of the last index.

Using len(s.items) which is out of range.

The top element of the stack is at the last index, which is len(s.items)-1.

2fill in blank

medium

Complete the code to check if the stack is empty before peeking.

DSA Go

func (s *Stack) Peek() (int, bool) {
    if [1] {
        return 0, false
    }
    return s.items[len(s.items)-1], true
}

Drag options to blanks, or click blank then click option'

Alen(s.items) != 0

Blen(s.items) > 0

Cs.items == nil

Dlen(s.items) == 0

Attempts:

3 left

💡 Hint

Common Mistakes

Checking if len(s.items) > 0 instead of == 0.

Checking if s.items == nil which may not be reliable.

We check if the length of items is zero to know if the stack is empty.

3fill in blank

hard

Fix the error in the Peek method to avoid runtime panic when stack is empty.

DSA Go

func (s *Stack) Peek() int {
    if len(s.items) == 0 {
        return [1]
    }
    return s.items[len(s.items)-1]
}

Drag options to blanks, or click blank then click option'

A-1

Bs.items[0]

C0

Dnil

Attempts:

3 left

💡 Hint

Common Mistakes

Returning s.items[0] causes panic if stack is empty.

Returning nil is invalid for int return type.

Returning -1 indicates the stack is empty without causing panic.

4fill in blank

hard

Fill both blanks to implement Peek that returns value and success flag.

DSA Go

func (s *Stack) Peek() (int, bool) {
    if [1] {
        return 0, [2]
    }
    return s.items[len(s.items)-1], true
}

Drag options to blanks, or click blank then click option'

Alen(s.items) == 0

Blen(s.items) > 0

Cfalse

Dtrue

Attempts:

3 left

💡 Hint

Common Mistakes

Returning true when stack is empty.

Checking len(s.items) > 0 instead of == 0.

Check if stack is empty and return false flag if yes.

5fill in blank

hard

Fill all three blanks to implement Peek with error handling using ok flag.

DSA Go

func (s *Stack) Peek() (int, bool) {
    if [1] {
        return [2], [3]
    }
    return s.items[len(s.items)-1], true
}

Drag options to blanks, or click blank then click option'

Alen(s.items) == 0

B0

Cfalse

D-1

Attempts:

3 left

💡 Hint

Common Mistakes

Returning -1 instead of 0 for empty stack.

Returning true when stack is empty.

Return 0 and false if stack is empty, else top element and true.

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