Check if Stack is Empty or Full in DSA Go - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output after pushing and popping on the stack?

Consider a stack with a maximum size of 3. What will be printed after the following operations?

DSA Go

package main
import "fmt"

type Stack struct {
    items []int
    maxSize int
}

func (s *Stack) Push(item int) bool {
    if len(s.items) == s.maxSize {
        return false
    }
    s.items = append(s.items, item)
    return true
}

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

func (s *Stack) IsEmpty() bool {
    return len(s.items) == 0
}

func (s *Stack) IsFull() bool {
    return len(s.items) == s.maxSize
}

func main() {
    stack := Stack{maxSize: 3}
    fmt.Println(stack.IsEmpty())
    stack.Push(10)
    stack.Push(20)
    fmt.Println(stack.IsFull())
    stack.Push(30)
    fmt.Println(stack.IsFull())
    stack.Pop()
    fmt.Println(stack.IsFull())
}

A

false
false
true
true

B

true
false
false
false

C

true
false
true
false

D

true
true
true
false

💡 Hint

Check the stack size before and after push/pop operations.

The stack starts empty, so IsEmpty() returns true.

After pushing 10 and 20, the stack is not full (size 2 of max 3), so IsFull() returns false.

After pushing 30, the stack reaches max size, so IsFull() returns true.

After popping one item, the stack size decreases, so IsFull() returns false.

🧠 Conceptual

intermediate

Which condition correctly checks if a stack is full?

Given a stack with a slice of items and a maxSize integer, which condition correctly returns true if the stack is full?

A len(stack.items) == stack.maxSize

B stack.maxSize == 0

C len(stack.items) < stack.maxSize

D len(stack.items) > stack.maxSize

💡 Hint

Full means the number of items equals the maximum allowed.

The stack is full when the number of items equals the maximum size.

Option A correctly checks this condition.

Other options either check wrong conditions or unrelated values.

🔧 Debug

advanced

What error occurs when calling Pop on an empty stack?

Consider the following Pop method for a stack. What happens if Pop is called when the stack is empty?

DSA Go

func (s *Stack) Pop() int {
    item := s.items[len(s.items)-1]
    s.items = s.items[:len(s.items)-1]
    return item
}

A returns zero value without error

B runtime error: index out of range

C compilation error due to missing return

D panic: nil pointer dereference

💡 Hint

What happens if len(s.items) is zero and you access s.items[len(s.items)-1]?

If the stack is empty, len(s.items) is 0.

Accessing s.items[len(s.items)-1] means s.items[-1], which is invalid.

This causes a runtime panic with 'index out of range' error.

❓ Predict Output

advanced

What is the output after checking empty and full states in sequence?

Given a stack with maxSize 2, what is printed after these operations?

DSA Go

package main
import "fmt"

type Stack struct {
    items []int
    maxSize int
}

func (s *Stack) IsEmpty() bool {
    return len(s.items) == 0
}

func (s *Stack) IsFull() bool {
    return len(s.items) == s.maxSize
}

func (s *Stack) Push(item int) bool {
    if s.IsFull() {
        return false
    }
    s.items = append(s.items, item)
    return true
}

func main() {
    stack := Stack{maxSize: 2}
    fmt.Println(stack.IsEmpty())
    stack.Push(5)
    fmt.Println(stack.IsFull())
    stack.Push(10)
    fmt.Println(stack.IsFull())
    stack.Push(15)
    fmt.Println(stack.IsFull())
}

A

false
false
true
true

B

true
false
true
false

C

true
true
true
false

D

true
false
true
true

💡 Hint

Check the stack size after each push and compare with maxSize.

Initially, stack is empty, so IsEmpty() returns true.

After pushing 5, stack size is 1, not full, so IsFull() returns false.

After pushing 10, stack size is 2, equals maxSize, so IsFull() returns true.

Trying to push 15 fails because stack is full, so size remains 2, IsFull() returns true.

🧠 Conceptual

expert

Why is it important to check if a stack is full before pushing?

In a fixed-size stack implementation, what is the main reason to check if the stack is full before pushing a new item?

A To avoid runtime errors by preventing overflow beyond max size

B To clear the stack when it reaches max size

C To automatically resize the stack when full

D To improve performance by skipping push operations

💡 Hint

What happens if you add items beyond the stack's capacity?

In fixed-size stacks, pushing beyond max size causes errors or corrupts data.

Checking if full prevents overflow and runtime errors.

Other options describe behaviors not typical for fixed-size stacks.

Practice

1. What does the IsEmpty() function check in a stack data structure?

easy

A. If the stack has no elements inside

B. If the stack is full and cannot add more elements

C. If the stack has exactly one element

D. If the stack has more than one element

Solution

1. Step 1: Understand the purpose of IsEmpty()

   The IsEmpty() function checks whether the stack contains any elements or not.

2. Step 2: Identify what empty means for a stack

   An empty stack means it has zero elements inside, so no items to pop or peek.

3. Final Answer:

   If the stack has no elements inside -> Option A

4. Quick Check:

   IsEmpty() means stack is empty = true [OK]

Hint: Empty means zero elements inside stack [OK]

Common Mistakes:

• Confusing empty with full
• Thinking empty means one element
• Mixing IsEmpty with IsFull

2. Which of the following is the correct Go syntax to check if a stack is full when using a fixed size array?

easy

A. if len(stack) == 0 { /* stack is full */ }

B. if top > len(stack) { /* stack is full */ }

C. if top == len(stack) - 1 { /* stack is full */ }

D. if top == 0 { /* stack is full */ }

Solution

1. Step 1: Understand stack indexing in Go

   For a fixed size array stack, top points to the last filled index. The last valid index is length - 1.

2. Step 2: Check condition for full stack

   When top equals len(stack) - 1, the stack is full because no more elements can be added.

3. Final Answer:

   if top == len(stack) - 1 { /* stack is full */ } -> Option C

4. Quick Check:

   top == max index means full [OK]

Hint: Full means top equals last index (length - 1) [OK]

Common Mistakes:

• Using > instead of == for full check
• Checking if top == 0 for full
• Confusing length with top index

3. Given the following Go code, what will be printed?

type Stack struct {
    items []int
    top   int
}

func (s *Stack) IsEmpty() bool {
    return s.top == -1
}

func main() {
    s := Stack{items: make([]int, 5), top: -1}
    fmt.Println(s.IsEmpty())
    s.top = 4
    fmt.Println(s.IsEmpty())
}

medium

A. true\nfalse

B. false\ntrue

C. false\nfalse

D. true\ntrue

Solution

1. Step 1: Check initial top value and IsEmpty() result

   Initially, top is -1, so IsEmpty() returns true because stack is empty.

2. Step 2: Update top to 4 and check IsEmpty() again

   After setting top to 4, IsEmpty() returns false because stack now has elements.

3. Final Answer:

   true\nfalse -> Option A

4. Quick Check:

   top -1 means empty true, top 4 means not empty false [OK]

Hint: top -1 means empty, any other top means not empty [OK]

Common Mistakes:

• Assuming top 4 means empty
• Confusing slice length with top
• Ignoring initial top value

4. Find the error in this Go code snippet that checks if a stack is full:

func (s *Stack) IsFull() bool {
    return s.top == len(s.items)
}

medium

A. The function should return 's.top > len(s.items)' instead

B. The condition should be 's.top == len(s.items) - 1' to check full correctly

C. The function should check if 's.top == 0' to be full

D. No error, the code is correct

Solution

1. Step 1: Understand stack indexing for full condition

   Stack top index starts at -1 and max valid index is length - 1.

2. Step 2: Identify correct full condition

   Full means top equals last valid index, which is len(s.items) - 1, not len(s.items).

3. Final Answer:

   The condition should be 's.top == len(s.items) - 1' to check full correctly -> Option B

4. Quick Check:

   Full means top == max index (length - 1) [OK]

Hint: Full means top equals last index, not length [OK]

Common Mistakes:

• Using length instead of length - 1
• Checking top == 0 for full
• Returning wrong boolean condition

5. You have a stack implemented with a fixed size array of length 3 and a top index starting at -1. After pushing two elements, you pop one element, then push two more elements. Which statement about the stack state is correct?

hard

A. The stack is empty and top index is -1

B. The stack is not full and top index is 1

C. The stack is full but top index is 3

D. The stack is full and top index is 2

Solution

1. Step 1: Track stack operations and top index changes

   Start: top = -1 (empty). Push two elements: top = 1. Pop one element: top = 0. Push two elements: top = 2 (max index for length 3).

2. Step 2: Determine if stack is full

   Since top = 2 and max index is 2 (length 3 - 1), stack is full.

3. Final Answer:

   The stack is full and top index is 2 -> Option D

4. Quick Check:

   Push/pop changes top; top 2 means full for size 3 [OK]

Hint: Track top index after each push/pop carefully [OK]

Common Mistakes:

• Assuming top can be 3 for full
• Forgetting pop decreases top
• Confusing empty with full states