Dequeue Operation in DSA Go - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to remove an element from the front of the dequeue.

DSA Go

func (dq *Dequeue) RemoveFront() int {
    if dq.IsEmpty() {
        return -1
    }
    frontElement := dq.data[dq.front]
    dq.front = dq.front [1] 1
    return frontElement
}

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

A*

B+

C-

D/

Attempts:

3 left

💡 Hint

Common Mistakes

Using '-' instead of '+' to move front pointer.

Using multiplication or division operators incorrectly.

To remove from the front, we move the front pointer forward by adding 1.

2fill in blank

medium

Complete the code to check if the dequeue is empty.

DSA Go

func (dq *Dequeue) IsEmpty() bool {
    return dq.front [1] dq.rear
}

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

A==

B!=

C>

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using '!=' which checks for not empty.

Using '>' or '<' which are incorrect for emptiness check.

The dequeue is empty when front and rear pointers are equal.

3fill in blank

hard

Fix the error in updating the rear pointer after removing an element from the rear.

DSA Go

func (dq *Dequeue) RemoveRear() int {
    if dq.IsEmpty() {
        return -1
    }
    rearElement := dq.data[dq.rear-1]
    dq.rear = dq.rear [1] 1
    return rearElement
}

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

A+

B/

C*

D-

Attempts:

3 left

💡 Hint

Common Mistakes

Using '+' which moves rear forward incorrectly.

Using multiplication or division operators.

After removing from rear, rear pointer moves backward by subtracting 1.

4fill in blank

hard

Fill both blanks to correctly add an element to the front of the dequeue.

DSA Go

func (dq *Dequeue) AddFront(value int) {
    if dq.IsFull() {
        return
    }
    dq.front = dq.front [1] 1
    dq.data[dq.front] = value
    dq.rear = dq.rear [2] 0
}

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

A-

B+

C=

D*

Attempts:

3 left

💡 Hint

Common Mistakes

Moving front pointer forward instead of backward.

Changing rear pointer incorrectly.

To add at front, front pointer moves backward by subtracting 1. Rear pointer remains unchanged, so '=' is used (rear = rear + 0).

5fill in blank

hard

Fill all three blanks to correctly add an element to the rear of the dequeue and update pointers.

DSA Go

func (dq *Dequeue) AddRear(value int) {
    if dq.IsFull() {
        return
    }
    dq.data[dq.rear] = value
    dq.rear = dq.rear [1] 1
    dq.front = dq.front [2] 0
    _ = dq.rear [3] dq.front
}

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

A+

B-

C=

D*

Attempts:

3 left

💡 Hint

Common Mistakes

Moving rear pointer backward instead of forward.

Changing front pointer incorrectly.

Adding at rear means rear pointer moves forward by adding 1. Front pointer remains unchanged, so '=' is used (front = front + 0). The last line is a dummy expression using '+' to avoid unused variable error.

Practice

1. What is a dequeue in data structures?

easy

A. A double-ended queue allowing insertion and deletion at both ends

B. A queue that only allows insertion at the rear and deletion at the front

C. A stack that allows insertion and deletion only at one end

D. A list that only supports random access

Solution

1. Step 1: Understand the definition of dequeue

   A dequeue is a data structure where elements can be added or removed from both the front and the rear ends.

2. Step 2: Compare with other data structures

   Unlike a queue or stack, which restrict operations to one end, dequeue supports both ends.

3. Final Answer:

   A double-ended queue allowing insertion and deletion at both ends -> Option A

4. Quick Check:

   Dequeue = double-ended queue [OK]

Hint: Remember: Dequeue means double-ended queue [OK]

Common Mistakes:

• Confusing dequeue with stack or simple queue
• Thinking dequeue only allows operations at one end
• Mixing dequeue with random access lists

2. Which of the following is the correct Go syntax to create an empty dequeue using a slice?

easy

A. var dq []int = make([]int, 0)

B. dq := []int{nil}

C. var dq int = []{}

D. dq := make([]int, -1)

Solution

1. Step 1: Understand slice creation in Go

   To create an empty slice, use make with length 0, like make([]int, 0).

2. Step 2: Check each option

   var dq []int = make([]int, 0) correctly creates an empty int slice. dq := []int{nil} uses nil inside slice literal which is invalid. var dq int = []{} has wrong type assignment. dq := make([]int, -1) tries negative length which is invalid.

3. Final Answer:

   var dq []int = make([]int, 0) -> Option A

4. Quick Check:

   Empty slice = make([]int, 0) [OK]

Hint: Use make([]type, 0) for empty slices in Go [OK]

Common Mistakes:

• Using nil inside slice literal
• Assigning wrong types
• Using negative length in make

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

package main
import "fmt"
func main() {
  dq := []int{10, 20, 30}
  // Remove from front
  dq = dq[1:]
  // Add 40 at rear
  dq = append(dq, 40)
  fmt.Println(dq)
}

medium

A. [40 20 30]

B. [10 20 30 40]

C. [20 30 40]

D. [30 40]

Solution

1. Step 1: Remove element from front

   dq = dq[1:] removes the first element (10), so dq becomes [20, 30].

2. Step 2: Add element at rear

   append(dq, 40) adds 40 at the end, so dq becomes [20, 30, 40].

3. Final Answer:

   [20 30 40] -> Option C

4. Quick Check:

   Remove front + append rear = [20 30 40] [OK]

Hint: Slice from 1 removes front; append adds rear [OK]

Common Mistakes:

• Forgetting slice removes front element
• Appending at wrong position
• Misreading slice syntax

4. Identify the error in the following Go code that tries to remove an element from the rear of a dequeue represented by a slice:

package main
import "fmt"
func main() {
  dq := []int{5, 10, 15}
  dq = dq[:len(dq)]
  fmt.Println(dq)
}

medium

A. No error; code correctly removes rear element

B. Runtime panic due to invalid slice bounds

C. Syntax error in slice expression

D. Slice operation does not remove last element; length unchanged

Solution

1. Step 1: Analyze slice operation dq[:len(dq)]

   This slice keeps all elements from start to length, so no element is removed.

2. Step 2: Understand how to remove last element

   To remove last element, slice should be dq[:len(dq)-1].

3. Final Answer:

   Slice operation does not remove last element; length unchanged -> Option D

4. Quick Check:

   dq[:len(dq)] keeps all elements [OK]

Hint: Use dq[:len(dq)-1] to remove last element [OK]

Common Mistakes:

• Using dq[:len(dq)] expecting removal
• Off-by-one errors in slicing
• Confusing slice length with index

5. Given a dequeue implemented as a slice in Go, which sequence of operations will correctly remove an element from the front and add an element at the front, resulting in [99 30 40] from initial [20 30 40]? Choose the correct code snippet:

package main
import "fmt"
func main() {
  dq := []int{20, 30, 40}
  // Your code here
  fmt.Println(dq)
}

hard

A. dq = append(dq, 99)
dq = dq[1:]

B. dq = dq[1:]
dq = append([]int{99}, dq...)

C. dq = append(dq, 99)
dq = append([]int{99}, dq...)

D. dq = dq[:len(dq)-1]
dq = append([]int{99}, dq...)

Solution

1. Step 1: Remove element from front

   dq = dq[1:] removes the first element (20), so dq becomes [30, 40].

2. Step 2: Add 99 at front

   dq = append([]int{99}, dq...) adds 99 at the front, resulting in [99, 30, 40].

3. Step 3: Verify final slice

   After these operations, dq is [99, 30, 40], which matches the expected result.

4. Final Answer:

   dq = dq[1:] dq = append([]int{99}, dq...) -> Option B

5. Quick Check:

   Remove front + add front = dq = dq[1:] dq = append([]int{99}, dq...) [OK]

Hint: Add front with append([]int{val}, dq...) [OK]

Common Mistakes:

• Removing wrong element before adding front
• Appending at rear instead of front
• Confusing slice operations order