Push Operation on Stack in DSA Go - Interactive Practice

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

Bs

Citems

Dstack

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong variable name instead of 'value'.

Trying to append the entire stack instead of the new value.

The Push method adds the given value to the end of the items slice representing the stack.

2fill in blank

medium

Complete the code to initialize a new empty stack.

DSA Go

func NewStack() *Stack {
    return &Stack{items: [1]
}

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

Amake([]int)

Bnil

Cmake([]int, 1)

D[]int{}

Attempts:

3 left

💡 Hint

Common Mistakes

Using nil which can cause runtime errors when appending.

Using make with incorrect length or missing capacity.

An empty slice literal '[]int{}' initializes the items slice as empty for the new stack.

3fill in blank

hard

Fix the error in the Push method to correctly add the value to the stack.

DSA Go

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

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

As.items

Bvalue

Cs

Ditems

Attempts:

3 left

💡 Hint

Common Mistakes

Appending to the wrong variable or value.

Using the stack pointer 's' directly instead of its items slice.

The append function must add 'value' to the slice 's.items' to update the stack correctly.

4fill in blank

hard

Fill both blanks to complete the Pop method that removes and returns the top element of the stack.

DSA Go

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

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

A- 1

B+ 1

C- 2

D+ 2

Attempts:

3 left

💡 Hint

Common Mistakes

Using +1 which causes out-of-range errors.

Using -2 which removes two elements instead of one.

To get the last element, subtract 1 from the length. To remove it, slice up to length minus 1.

5fill in blank

hard

Fill all three blanks to complete the Peek method that returns the top element without removing it.

DSA Go

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

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

A- 1

Btrue

Cfalse

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Returning false which indicates failure.

Using +1 which causes index out of range.

Peek returns the last element at index length - 1 and true indicating success.

Practice

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

easy

A. Returns the bottom element of the stack

B. Removes the top element from the stack

C. Adds an element to the top of the stack

D. Checks if the stack is empty

Solution

1. Step 1: Understand stack behavior

   A stack follows Last In First Out (LIFO) principle, so new elements are added on top.

2. Step 2: Define push operation

   The push operation adds a new element to the top of the stack.

3. Final Answer:

   Adds an element to the top of the stack -> Option C

4. Quick Check:

   Push = Add top [OK]

Hint: Push means add on top of stack [OK]

Common Mistakes:

• Confusing push with pop operation
• Thinking push removes elements
• Assuming push accesses bottom element

2. Which of the following is the correct syntax to push an element 5 onto a stack named s in Go?

easy

A. s.push(5)

B. s.Push(5)

C. push(s, 5)

D. s = append(s, 5)

Solution

1. Step 1: Understand Go slice as stack

   In Go, stacks are often implemented using slices. To push, append adds element at the end.

2. Step 2: Identify correct syntax

   Using append(s, 5) adds 5 to the slice s, simulating push.

3. Final Answer:

   s = append(s, 5) -> Option D

4. Quick Check:

   Go push = append slice [OK]

Hint: Use append to push in Go slices [OK]

Common Mistakes:

• Using lowercase push method which doesn't exist
• Calling push as a function without method
• Ignoring that slices need reassignment after append

3. What will be the output after executing this Go code?

stack := []int{1, 2, 3}
stack = append(stack, 4)
fmt.Println(stack)

medium

A. [1 2 3 4]

B. [4 1 2 3]

C. [1 2 3]

D. runtime error

Solution

1. Step 1: Initial stack state

   Stack slice starts as [1 2 3].

2. Step 2: Append 4 to stack

   Append adds 4 at the end, so stack becomes [1 2 3 4].

3. Final Answer:

   [1 2 3 4] -> Option A

4. Quick Check:

   Append adds at end [OK]

Hint: Append adds element at slice end [OK]

Common Mistakes:

• Expecting append to add at start
• Confusing append with insert
• Thinking append causes error without reassignment

4. Identify the error in this Go code that tries to push an element onto a stack:

var stack []int
stack.push(10)

medium

A. Stack is not initialized

B. push method does not exist for slices

C. Missing import for stack package

D. Cannot push integer 10

Solution

1. Step 1: Check stack type and methods

   Stack is a slice of int. Slices do not have a push method in Go.

2. Step 2: Identify correct push approach

   To push, use append function instead of push method.

3. Final Answer:

   push method does not exist for slices -> Option B

4. Quick Check:

   Slices lack push method [OK]

Hint: Slices use append, no push method [OK]

Common Mistakes:

• Assuming push is built-in method for slices
• Thinking stack must be initialized first
• Believing import fixes method absence

5. Given a stack implemented as a slice in Go, how would you push multiple elements 7, 8, 9 in one operation?

hard

A. stack = append(stack, []int{7, 8, 9}...)

B. stack.push(7); stack.push(8); stack.push(9)

C. append(stack, 7, 8, 9)

D. stack = append(stack, []int{7, 8, 9})

Solution

1. Step 1: Understand appending multiple elements

   To add multiple elements from a slice, use the ... operator to unpack them.

2. Step 2: Identify correct append syntax

   Using append(stack, []int{7, 8, 9}...) adds all three elements individually.

3. Final Answer:

   stack = append(stack, []int{7, 8, 9}...) -> Option A

4. Quick Check:

   Use ... to unpack slice in append [OK]

Hint: Use ... to append multiple elements at once [OK]

Common Mistakes:

• Forgetting to assign the result of append back to stack
• Using non-existent push method multiple times
• Appending slice without unpacking elements