Array Deletion at Beginning in DSA Go - Cheat Sheet & Quick Revision

Recall & Review

beginner

What happens when you delete the first element of an array?

The first element is removed, and all other elements shift one position to the left to fill the gap.

beginner

Why is deleting the first element of an array less efficient than deleting the last element?

Because after deleting the first element, all remaining elements must be moved one step left, which takes more time.

beginner

In Go, how can you delete the first element of a slice named 'arr'?

You can delete it by re-slicing: arr = arr[1:]

intermediate

What is the time complexity of deleting the first element in a typical array?

O(n), because all elements after the first must be shifted left by one position.

beginner

What is a real-life example to understand array deletion at the beginning?

Imagine a line of people waiting. If the first person leaves, everyone behind moves forward one step to fill the space.

What happens to the elements after deleting the first element of an array?

A They shift one position to the left

B They shift one position to the right

C They remain in the same position

D They get deleted too

When the first element is deleted, all other elements move left to fill the empty space.

In Go, how do you remove the first element from a slice named 'arr'?

A arr = arr[:len(arr)-1]

B arr = arr[1:]

C arr = append(arr, 0)

D arr = arr[0:]

Re-slicing with arr[1:] removes the first element by starting the slice from index 1.

What is the time complexity of deleting the first element in an array?

A O(1)

B O(n^2)

C O(n)

D O(log n)

Deleting the first element requires shifting all other elements, which takes O(n) time.

Which of these is a disadvantage of deleting the first element in an array?

A Shifting all elements is costly

B Array size increases

C No shifting needed

D Array becomes sorted

Shifting all elements after deletion is costly in time and performance.

If an array has 5 elements, what will be the new first element after deleting the first element?

A No element remains

B The original last element

C The original first element

D The original second element

After deleting the first element, the second element moves to the first position.

Explain how deleting the first element of an array affects the array structure and performance.

Think about what happens to the rest of the elements after the first is removed.

Describe how to delete the first element of a slice in Go and why this operation is efficient or not.

Focus on Go slice behavior and what happens under the hood.

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