Array Deletion at Beginning in DSA Go - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output after deleting first element from array

What is the output of this Go code after deleting the first element from the array?

DSA Go

package main
import "fmt"
func main() {
  arr := []int{10, 20, 30, 40, 50}
  arr = arr[1:]
  fmt.Println(arr)
}

A [30 40 50]

B [20 30 40 50]

C [10 20 30 40]

D [10 20 30 40 50]

💡 Hint

Slicing an array from index 1 removes the first element.

In Go, slicing arr[1:] creates a new slice starting from index 1, effectively removing the first element (10). The resulting slice contains [20 30 40 50].

❓ Predict Output

intermediate

Result of deleting first element and appending new value

What is the output after deleting the first element and appending 60 to the slice?

DSA Go

package main
import "fmt"
func main() {
  arr := []int{5, 15, 25, 35}
  arr = arr[1:]
  arr = append(arr, 60)
  fmt.Println(arr)
}

A [25 35 60]

B [5 15 25 35 60]

C [15 25 35]

D [15 25 35 60]

💡 Hint

After slicing, append adds the new element at the end.

After arr = arr[1:], the slice is [15 25 35]. Appending 60 adds it to the end, resulting in [15 25 35 60].

🔧 Debug

advanced

Identify the error when deleting first element from fixed array

What error occurs when trying to delete the first element from a fixed-size array using slicing?

DSA Go

package main
import "fmt"
func main() {
  var arr [4]int = [4]int{1, 2, 3, 4}
  arr = arr[1:]
  fmt.Println(arr)
}

A index out of range runtime error

B compiles and prints [2 3 4]

C cannot assign to arr (type [4]int) from arr[1:] (type []int)

D syntax error: missing colon after for

💡 Hint

Arrays and slices are different types in Go.

In Go, fixed arrays ([4]int) and slices ([]int) are different types. Slicing an array returns a slice, so assigning arr[1:] (slice) to arr (array) causes a type mismatch error.

🧠 Conceptual

advanced

Effect of deleting first element on slice capacity

After deleting the first element from a slice using slicing (arr = arr[1:]), what happens to the capacity of the slice?

A Capacity decreases by one

B Capacity remains the same

C Capacity increases by one

D Capacity becomes zero

💡 Hint

The capacity of arr[1:] is cap(arr) - 1.

Slicing arr = arr[1:] creates a new slice header pointing to the same underlying array but starting at index 1. The length decreases by 1, and the capacity decreases by 1 (cap(arr) - 1).

🚀 Application

expert

Efficiently delete first element from large slice without memory leak

Which approach efficiently deletes the first element from a large slice without causing the underlying array to retain the removed element and waste memory?

A copy(arr, arr[1:]); arr = arr[:len(arr)-1]

B arr = nil; arr = arr[1:]

C arr = append(arr[:0], arr[1:]...)

D arr = arr[1:]

💡 Hint

Removing references to the first element helps garbage collection.

Using copy shifts elements left, then slicing shortens the slice, removing references to the first element and allowing garbage collection. Simply slicing (arr = arr[1:]) keeps reference to the original array, causing memory to be retained.

Practice

1. What happens to the array [10, 20, 30, 40] after deleting the first element at the beginning?

easy

A. [40]

B. [10, 20, 30]

C. [20, 30, 40]

D. [30, 40]

Solution

1. Step 1: Understand deletion at beginning

   Deleting the first element removes the element at index 0, which is 10.

2. Step 2: Shift remaining elements left

   The remaining elements 20, 30, 40 shift left to fill the gap, resulting in [20, 30, 40].

3. Final Answer:

   [20, 30, 40] -> Option C

4. Quick Check:

   Remove first element = [20, 30, 40] [OK]

Hint: Remove first element, shift left, rest remain [OK]

Common Mistakes:

• Removing last element instead of first
• Not shifting elements left after deletion
• Leaving the first element in place

2. Which of the following Go code snippets correctly deletes the first element from a slice arr?

easy

A. arr = append(arr, 0)

B. arr = arr[1:]

C. arr = arr[:len(arr)-1]

D. arr = arr[0:]

Solution

1. Step 1: Understand slice slicing syntax

   In Go, arr[1:] creates a slice from index 1 to end, effectively removing the first element.

2. Step 2: Check other options

   arr[:len(arr)-1] removes last element, append(arr, 0) adds element, arr[0:] returns full slice.

3. Final Answer:

   arr = arr[1:] -> Option B

4. Quick Check:

   Slice from index 1 removes first element [OK]

Hint: Use arr = arr[1:] to drop first element [OK]

Common Mistakes:

• Using arr[:len(arr)-1] deletes last element
• Appending instead of slicing
• Using arr[0:] which does not delete anything

3. What is the output of the following Go code?

arr := []int{5, 10, 15, 20}
arr = arr[1:]
fmt.Println(arr)

medium

A. [5 10 15 20]

B. []

C. [15 20]

D. [10 15 20]

Solution

1. Step 1: Initial array elements

   arr starts as [5, 10, 15, 20].

2. Step 2: Slice from index 1

   arr = arr[1:] removes first element 5, resulting in [10, 15, 20].

3. Final Answer:

   [10 15 20] -> Option D

4. Quick Check:

   arr[1:] drops first element [OK]

Hint: arr[1:] slices from second element onward [OK]

Common Mistakes:

• Printing original array without slicing
• Confusing arr[:1] with arr[1:]
• Expecting output with commas instead of spaces

4. The following Go code tries to delete the first element from arr. What is the error?

arr := []int{1, 2, 3, 4}
arr = arr[0:len(arr)]
fmt.Println(arr)

medium

A. No deletion happens; array remains unchanged

B. Syntax error due to incorrect slicing

C. Runtime panic due to out of range slice

D. Deletes last element instead of first

Solution

1. Step 1: Analyze slicing range

   arr[0:len(arr)] returns the full slice unchanged.

2. Step 2: Check effect on array

   Since no elements are removed, arr remains [1, 2, 3, 4].

3. Final Answer:

   No deletion happens; array remains unchanged -> Option A

4. Quick Check:

   Slicing full range keeps array same [OK]

Hint: arr[0:len(arr)] returns full slice, no deletion [OK]

Common Mistakes:

• Assuming slicing deletes first element
• Expecting runtime error from slicing
• Confusing slicing syntax with deletion

5. Given a slice arr := []int{7, 14, 21, 28, 35}, write the Go code to delete the first two elements and print the resulting slice.

hard

A. arr = arr[2:]
fmt.Println(arr)

B. arr = arr[:len(arr)-2]
fmt.Println(arr)

C. arr = arr[1:]
fmt.Println(arr)

D. arr = append(arr[:2], arr[2:]...)
fmt.Println(arr)

Solution

1. Step 1: Understand deletion of first two elements

   To delete first two elements, slice from index 2 to end: arr[2:].

2. Step 2: Verify other options

   arr[:len(arr)-2] removes last two elements, arr[1:] removes only first element, append(arr[:2], arr[2:]...) reconstructs the original slice.

3. Final Answer:

   arr = arr[2:] fmt.Println(arr) -> Option A

4. Quick Check:

   Slice from index 2 removes first two elements [OK]

Hint: Use arr = arr[2:] to remove first two elements [OK]

Common Mistakes:

• Removing last elements instead of first
• Removing only one element instead of two
• Using append unnecessarily for simple slicing