Array Deletion at Beginning in DSA Go

Mental Model

Removing the first item from a list means shifting all other items one step left to fill the empty space.

Analogy: Imagine a row of chairs where the first person leaves, and everyone else moves one chair forward to fill the gap.

[1] -> [2] -> [3] -> [4] -> null
↑start

Dry Run Walkthrough

Input: array: [1, 2, 3, 4], delete element at beginning

Goal: Remove the first element and shift remaining elements left

Step 1: Remove element at index 0 (value 1)

[ ] -> [2] -> [3] -> [4] -> null
↑gap at index 0

Why: We remove the first element, leaving a gap at the start

Step 2: Shift element at index 1 (value 2) to index 0

[2] -> [2] -> [3] -> [4] -> null
↑gap at index 1

Why: Shift left to fill the gap

Step 3: Shift element at index 2 (value 3) to index 1

[2] -> [3] -> [3] -> [4] -> null
↑gap at index 2

Why: Continue shifting elements left

Step 4: Shift element at index 3 (value 4) to index 2

[2] -> [3] -> [4] -> [4] -> null
↑gap at index 3

Why: Shift last element left

Step 5: Remove duplicate last element at index 3

[2] -> [3] -> [4] -> null

Why: Remove leftover duplicate after shifting

Result:

[2] -> [3] -> [4] -> null

Annotated Code

DSA Go

package main

import "fmt"

// deleteAtBeginning removes the first element from the array by shifting all elements left
func deleteAtBeginning(arr []int) []int {
	if len(arr) == 0 {
		return arr // empty array, nothing to delete
	}
	for i := 1; i < len(arr); i++ {
		arr[i-1] = arr[i] // shift element left
	}
	return arr[:len(arr)-1] // return array without last duplicate
}

func main() {
	arr := []int{1, 2, 3, 4}
	fmt.Println("Original array:", arr)
	arr = deleteAtBeginning(arr)
	fmt.Println("After deletion at beginning:", arr)
}

if len(arr) == 0 { return arr }

handle empty array edge case to avoid errors

for i := 1; i < len(arr); i++ { arr[i-1] = arr[i] }

shift each element left by one to overwrite the first element

return arr[:len(arr)-1]

return array slice excluding last duplicate element

Output

Original array: [1 2 3 4]

After deletion at beginning: [2 3 4]

Complexity Analysis

Time: O(n) because we shift all n-1 elements one position left

Space: O(1) because shifting is done in place without extra storage

vs Alternative: Compared to creating a new array without the first element (O(n) time and O(n) space), this method saves space by modifying in place

Edge Cases

empty array

returns empty array without error

DSA Go

if len(arr) == 0 { return arr }

single element array

returns empty array after deletion

DSA Go

return arr[:len(arr)-1]

When to Use This Pattern

When you need to remove the first item from a list and keep the order, use array deletion at beginning by shifting elements left.

Common Mistakes

Mistake: Not shifting elements left and just removing the first element, leaving a gap
Fix: Shift all elements left to fill the gap before resizing the array

Mistake: Forgetting to reduce the array size after shifting, causing duplicate last element
Fix: Return the array slice excluding the last element after shifting

Summary

Deletes the first element of an array by shifting all other elements left.

Use when you want to remove the first item but keep the order of remaining items.

The key is to shift elements left to fill the gap and then shorten the array.

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