Stack Implementation Using Array in DSA Go - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare the stack array with a fixed size of 5.

DSA Go

var stack [[1]]int

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

A10

B5

C3

D7

Attempts:

3 left

💡 Hint

Common Mistakes

Using a size other than 5 for the stack array.

Forgetting to specify the size inside the brackets.

The stack array is declared with size 5 to hold up to 5 elements.

2fill in blank

medium

Complete the code to initialize the top index of the stack to -1.

DSA Go

var top = [1]

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

A-1

B0

C1

D5

Attempts:

3 left

💡 Hint

Common Mistakes

Initializing top to 0 which means stack has one element.

Using a positive number which is incorrect for empty stack.

The top index is initialized to -1 to indicate the stack is empty.

3fill in blank

hard

Fix the error in the Push function to correctly add an element to the stack.

DSA Go

func Push(value int) {
    if top == len(stack)-1 {
        fmt.Println("Stack Overflow")
        return
    }
    top = top [1] 1
    stack[top] = value
}

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

A-

B/

C*

D+

Attempts:

3 left

💡 Hint

Common Mistakes

Using subtraction which moves top down incorrectly.

Using multiplication or division which is not logical here.

We increase top by 1 before adding the new value to the stack.

4fill in blank

hard

Fill both blanks to complete the Pop function that removes and returns the top element.

DSA Go

func Pop() int {
    if top == [1] {
        fmt.Println("Stack Underflow")
        return -1
    }
    value := stack[top]
    top = top [2] 1
    return value
}

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

A-1

B0

C+

D-

Attempts:

3 left

💡 Hint

Common Mistakes

Checking top == 0 which is wrong for empty stack.

Increasing top after popping which is incorrect.

Check if top is -1 to detect empty stack. Decrease top by 1 after popping.

5fill in blank

hard

Fill both blanks to complete the Peek function that returns the top element without removing it.

DSA Go

func Peek() int {
    if top == [1] {
        fmt.Println("Stack is empty")
        return [2]
    }
    return stacktop
}

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

A-1

B0

C[

D(

Attempts:

3 left

💡 Hint

Common Mistakes

Using parentheses instead of square brackets for array access.

Returning -1 instead of 0 when stack is empty.

Check if top is -1 for empty stack. Return 0 as default.

Practice

1. What is the main purpose of using an array to implement a stack?

easy

A. To sort elements automatically

B. To store elements in a first-in, first-out (FIFO) order

C. To store elements in a last-in, first-out (LIFO) order

D. To allow random access to elements

Solution

1. Step 1: Understand stack behavior

   A stack stores elements so the last added is the first removed, called LIFO.

2. Step 2: Role of array in stack

   An array holds elements in order, supporting push/pop at one end to maintain LIFO.

3. Final Answer:

   To store elements in a last-in, first-out (LIFO) order -> Option C

4. Quick Check:

   Stack = LIFO [OK]

Hint: Stack means last-in, first-out order [OK]

Common Mistakes:

• Confusing stack with queue (FIFO)
• Thinking array sorts elements automatically
• Assuming random access is main stack feature

2. Which of the following is the correct way to declare a stack using an array in Go?

easy

A. stack := []int{}

B. stack := array int

C. var stack [10]int

D. var stack int[]

Solution

1. Step 1: Understand Go slice declaration

   In Go, slices are dynamic arrays declared as []type{}, e.g., []int{}.

2. Step 2: Check options for correct syntax

   stack := []int{} uses correct slice literal syntax to create an empty int slice.

3. Final Answer:

   stack := []int{} -> Option A

4. Quick Check:

   Go slice syntax = []type{} [OK]

Hint: Use slice literal []int{} to declare empty stack [OK]

Common Mistakes:

• Using array keyword incorrectly
• Wrong order of type and brackets
• Declaring fixed size array instead of slice

3. What will be the output of the following Go code snippet implementing a stack push and pop?

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

medium

A. 10
[]

B. 20
[10]

C. 20
[10 20]

D. 10
[20]

Solution

1. Step 1: Trace push operations

   stack starts empty, append 10 -> [10], append 20 -> [10, 20]

2. Step 2: Trace pop operation

   top = last element = 20, then remove last element -> stack becomes [10]

3. Final Answer:

   20 [10] -> Option B

4. Quick Check:

   Pop returns 20, stack left with 10 [OK]

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

Common Mistakes:

• Printing stack before pop
• Confusing first element with last
• Not slicing stack correctly after pop

4. Identify the error in this Go code snippet for stack push operation:

package main
func main() {
  var stack []int
  stack[len(stack)] = 5
}

medium

A. Index out of range error

B. Syntax error: missing import

C. No error, code runs fine

D. Type mismatch error

Solution

1. Step 1: Understand slice indexing

   Accessing stack[len(stack)] tries to assign beyond current slice length, causing error.

2. Step 2: Correct push uses append

   To add element, use append(stack, 5) instead of direct index assignment.

3. Final Answer:

   Index out of range error -> Option A

4. Quick Check:

   Assigning at len(slice) causes index error [OK]

Hint: Use append to add elements, not direct index [OK]

Common Mistakes:

• Trying to assign at slice length index
• Forgetting to import fmt (not needed here)
• Assuming slice auto-expands on index assignment

5. Given a stack implemented using an array in Go, how would you modify the pop operation to safely handle popping from an empty stack without causing a runtime error?

hard

A. Replace the stack with a map to avoid empty pop errors

B. Always pop without checking; Go handles empty slices gracefully

C. Use a for loop to pop all elements at once

D. Check if stack length is zero before popping and return an error or zero value

Solution

1. Step 1: Understand pop risk on empty stack

   Popping from empty slice causes index out of range runtime error.

2. Step 2: Add length check before pop

   Check if len(stack) == 0; if yes, return error or zero value to avoid crash.

3. Final Answer:

   Check if stack length is zero before popping and return an error or zero value -> Option D

4. Quick Check:

   Empty stack pop needs length check [OK]

Hint: Always check stack length before pop to avoid errors [OK]

Common Mistakes:

• Ignoring empty stack check causing runtime panic
• Using map instead of array unnecessarily
• Trying to pop all elements in a loop without condition