Why Stack Exists and What Problems It Solves in DSA Go - Test Your Knowledge

Practice - 5 Tasks

1fill in blank

easy

Complete the code to push an element onto the stack.

DSA Go

func (s *Stack) Push(value int) {
    s.items = append(s.items, [1])
}

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

Avalue

Bstack

Citems

Ds

Attempts:

3 left

💡 Hint

Common Mistakes

Using the stack itself instead of the value.

Trying to append the entire stack instead of a single value.

We add the given value to the stack's items slice using append.

2fill in blank

medium

Complete the code to pop the top element from the stack.

DSA Go

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

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

A-2

B-0

C-3

D-1

Attempts:

3 left

💡 Hint

Common Mistakes

Using -2 as index which accesses the wrong element.

Using length without subtracting one.

To get the last element, we use len(s.items)-1 as index because Go slices are zero-based and length minus one is the last element.

3fill in blank

hard

Fix the error in the code to check if the stack is empty.

DSA Go

func (s *Stack) IsEmpty() bool {
    return len(s.items) [1] 0
}

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

A<

B==

C!=

D=

Attempts:

3 left

💡 Hint

Common Mistakes

Using '=' instead of '==' causes syntax error.

Using '!=' returns true when stack is not empty.

To check if the stack is empty, we compare length to zero using ==.

4fill in blank

hard

Fill both blanks to create a stack and push a value.

DSA Go

s := &Stack{items: [1]
s.Push([2])

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

A[]int{}

B10

Cnil

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using nil slice instead of empty slice.

Pushing zero instead of intended value.

We initialize the stack with an empty slice []int{} and push the value 10.

5fill in blank

hard

Fill all three blanks to peek the top element safely.

DSA Go

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

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

A==

B-1

D!=

Attempts:

3 left

💡 Hint

Common Mistakes

Using '!=' instead of '==' in condition.

Using wrong index for last element.

We check if the stack is empty with == 0, return -1 if empty, else return the last element at index len(s.items)-1.

Practice

1. Why do we use a stack data structure in programming?

easy

A. To sort numbers in ascending order automatically

B. To store data in random order for quick access

C. To keep track of function calls and return in the correct order

D. To store data permanently on disk

Solution

1. Step 1: Understand the role of stack in function calls

   Stacks help keep track of which function called which, so the program can return to the right place after finishing a function.

2. Step 2: Recognize the order of operations in stacks

   Stacks follow Last In First Out (LIFO), which matches how function calls return in reverse order.

3. Final Answer:

   To keep track of function calls and return in the correct order -> Option C

4. Quick Check:

   Stack = function call tracking [OK]

Hint: Stack tracks last function called first returned [OK]

Common Mistakes:

• Thinking stack stores data randomly
• Confusing stack with sorting
• Assuming stack stores data permanently

2. Which of the following is the correct way to push an element onto a stack in Go using a slice?

easy

A. stack = append(stack, element)

B. stack.push(element)

C. stack.add(element)

D. stack.insert(element)

Solution

1. Step 1: Recall how slices work in Go

   In Go, slices can be appended using the built-in append function.

2. Step 2: Identify the correct syntax for adding to stack

   Since stack is a slice, adding an element is done by stack = append(stack, element).

3. Final Answer:

   stack = append(stack, element) -> Option A

4. Quick Check:

   Go slice append = push stack [OK]

Hint: Use append() to add element to slice stack [OK]

Common Mistakes:

• Using non-existent push method on slice
• Using add or insert which are not Go slice methods
• Forgetting to assign back to stack after append

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

B. 30

C. Error

D. 20

Solution

1. Step 1: Trace the stack after each append

   After appending 10, 20, 30, stack = [10, 20, 30].

2. Step 2: Identify the last element and remove it

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

3. Final Answer:

   30 -> Option B

4. Quick Check:

   Last pushed = 30 popped = 30 [OK]

Hint: Last appended element is popped and printed [OK]

Common Mistakes:

• Printing first element instead of last
• Confusing slice indexing
• Expecting error due to slicing

4. Find the error in this Go code that tries to pop an element from a stack represented by a slice:

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

medium

A. Index out of range error when accessing stack[len(stack)]

B. Syntax error in slice operation

C. No error, code works fine

D. Stack slice is empty before pop

Solution

1. Step 1: Check indexing used to get last element

   stack[len(stack)] tries to access index equal to length, which is out of range (indexes go from 0 to len-1).

2. Step 2: Confirm correct index for last element

   The last element is at stack[len(stack)-1], so the code causes runtime error.

3. Final Answer:

   Index out of range error when accessing stack[len(stack)] -> Option A

4. Quick Check:

   Indexing error = Index out of range error when accessing stack[len(stack)] [OK]

Hint: Last element index is length-1, not length [OK]

Common Mistakes:

• Using len(stack) as index instead of len(stack)-1
• Assuming slice indexing starts at 1
• Ignoring runtime errors

5. You want to reverse a string using a stack in Go. Which approach correctly uses a stack to reverse the string "hello"?

hard

A. Sort characters alphabetically to reverse string

B. Append characters directly to a new string without stack

C. Use a queue to store characters and dequeue to reverse

D. Push each character onto a stack, then pop all to build reversed string

Solution

1. Step 1: Understand stack's LIFO property for reversing

   Pushing characters in order and popping reverses their order.

2. Step 2: Identify correct method to reverse string using stack

   Push all chars, then pop to build reversed string matches stack usage.

3. Final Answer:

   Push each character onto a stack, then pop all to build reversed string -> Option D

4. Quick Check:

   Stack LIFO reverses string [OK]

Hint: Stack reverses order by popping last pushed first [OK]

Common Mistakes:

• Using queue which reverses differently
• Appending without stack does not use stack concept
• Sorting changes order, not reverses