Enqueue Operation in DSA Go - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to add an element to the queue.

DSA Go

func (q *Queue) Enqueue(value int) {
    q.items = append(q.items, [1])
}

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

Avalue

Bq

Citems

Denqueue

Attempts:

3 left

💡 Hint

Common Mistakes

Using the queue itself instead of the value.

Appending the wrong variable name.

The Enqueue method adds the given value to the end of the queue's items slice using append.

2fill in blank

medium

Complete the code to initialize a new empty queue.

DSA Go

func NewQueue() *Queue {
    return &Queue{items: [1]
}

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

A[]int{}

Bnil

Cmake([]int, 1)

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using nil which can cause runtime errors when appending.

Using make with length 1 which creates a slice with one zero element.

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

3fill in blank

hard

Fix the error in the Enqueue method to correctly add the value.

DSA Go

func (q *Queue) Enqueue(value int) {
    q.items = append(q.items, [1])
}

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

Aq

Bitems

Cvalue

Denqueue

Attempts:

3 left

💡 Hint

Common Mistakes

Appending the queue pointer instead of the value.

Using incorrect variable names.

The append function must add the 'value' parameter to the items slice to enqueue it.

4fill in blank

hard

Fill both blanks to complete the Enqueue method and print the queue after adding.

DSA Go

func (q *Queue) Enqueue(value int) {
    q.items = append(q.items, [1])
    fmt.Println([2])
}

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

Avalue

Bq.items

Citems

Attempts:

3 left

💡 Hint

Common Mistakes

Printing the wrong variable.

Appending incorrect variable.

Append the 'value' to q.items, then print q.items to show the queue state.

5fill in blank

hard

Fill all three blanks to enqueue a value and return the new length of the queue.

DSA Go

func (q *Queue) Enqueue(value int) int {
    q.items = append(q.items, [1])
    length := len([2])
    return [3]
}

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

Avalue

Bq.items

Clength

Attempts:

3 left

💡 Hint

Common Mistakes

Returning the value instead of the length.

Using wrong variable names for length.

Append 'value' to q.items, get length of q.items, and return length to show queue size.

Practice

1. What does the enqueue operation do in a queue data structure?

easy

A. Removes an element from the front of the queue

B. Checks if the queue is empty

C. Adds an element to the end of the queue

D. Returns the size of the queue

Solution

1. Step 1: Understand the queue structure

   A queue works like a line where new elements join at the end.

2. Step 2: Define enqueue operation

   Enqueue means adding a new element to the back of the queue.

3. Final Answer:

   Adds an element to the end of the queue -> Option C

4. Quick Check:

   Enqueue = Add at end [OK]

Hint: Enqueue means add at the back of the queue [OK]

Common Mistakes:

• Confusing enqueue with dequeue
• Thinking enqueue removes elements
• Mixing enqueue with checking size

2. Which of the following is the correct syntax to enqueue an element 5 into a queue named q in Go?

easy

A. q.Enqueue(5)

B. q.enqueue(5)

C. enqueue(q, 5)

D. q.add(5)

Solution

1. Step 1: Identify method naming conventions in Go

   Methods in Go are usually capitalized if exported, so Enqueue is correct.

2. Step 2: Check method call on queue instance

   Calling q.Enqueue(5) means calling method Enqueue on queue q with argument 5.

3. Final Answer:

   q.Enqueue(5) -> Option A

4. Quick Check:

   Method call with capital Enqueue = q.Enqueue(5) [OK]

Hint: Use capitalized method names for exported functions in Go [OK]

Common Mistakes:

• Using lowercase method names incorrectly
• Calling enqueue as a standalone function
• Using wrong method name like add

3. What will be the output of the following Go code snippet?

package main

import "fmt"

type Queue struct {
    items []int
}

func (q *Queue) Enqueue(val int) {
    q.items = append(q.items, val)
}

func (q *Queue) Print() {
    for _, v := range q.items {
        fmt.Print(v, " -> ")
    }
    fmt.Println("null")
}

func main() {
    q := Queue{}
    q.Enqueue(10)
    q.Enqueue(20)
    q.Enqueue(30)
    q.Print()
}

medium

A. Compilation error

B. 10 -> 20 -> 30 -> null

C. null

D. 30 -> 20 -> 10 -> null

Solution

1. Step 1: Understand enqueue implementation

   Enqueue appends new values at the end of the slice, so order is preserved as inserted.

2. Step 2: Trace the Print method output

   Print prints all items in order separated by ' -> ' and ends with 'null'.

3. Final Answer:

   10 -> 20 -> 30 -> null -> Option B

4. Quick Check:

   Enqueue appends, so output is 10 -> 20 -> 30 -> null [OK]

Hint: Enqueue appends at end, print shows order inserted [OK]

Common Mistakes:

• Thinking enqueue adds at front
• Confusing print order
• Assuming code has errors

4. Identify the error in the following Go code for enqueue operation:

package main

import "fmt"

type Queue struct {
    items []int
}

func (q Queue) Enqueue(val int) {
    q.items = append(q.items, val)
}

func main() {
    q := Queue{}
    q.Enqueue(5)
    fmt.Println(q.items)
}

medium

A. Enqueue method should have pointer receiver to modify queue

B. items slice should be initialized with make

C. fmt.Println is not imported

D. Append cannot be used on slices

Solution

1. Step 1: Check method receiver type

   The Enqueue method uses a value receiver, so changes to q.items do not affect original queue.

2. Step 2: Understand pointer receiver necessity

   To modify the original queue, Enqueue must have pointer receiver (q *Queue).

3. Final Answer:

   Enqueue method should have pointer receiver to modify queue -> Option A

4. Quick Check:

   Pointer receiver needed to modify struct [OK]

Hint: Use pointer receiver to modify struct fields [OK]

Common Mistakes:

• Using value receiver and expecting changes
• Forgetting to import fmt (not main error here)
• Thinking append can't be used on slices

5. You want to implement a queue using a linked list in Go. Which step is essential in the Enqueue operation to maintain the queue correctly?

hard

A. Add new node at the head and do not update head pointer

B. Add new node at the head and update tail pointer

C. Add new node at the tail but do not update tail pointer

D. Add new node at the tail and update tail pointer

Solution

1. Step 1: Understand linked list queue structure

   Queue adds new elements at the tail (end) and removes from head (front).

2. Step 2: Enqueue operation details

   To enqueue, add new node at tail and update tail pointer to new node to keep track.

3. Final Answer:

   Add new node at the tail and update tail pointer -> Option D

4. Quick Check:

   Enqueue adds at tail and updates tail pointer [OK]

Hint: Enqueue adds at tail and updates tail pointer [OK]

Common Mistakes:

• Adding at head instead of tail
• Not updating tail pointer after enqueue
• Confusing head and tail roles