Array Deletion at Beginning in DSA Go - Execution Trace

Concept Flow - Array Deletion at Beginning

Start with array

↓

Delete first element

↓

Shift all elements left by 1

↓

Reduce array size by 1

↓

Resulting array without first element

This flow shows deleting the first element of an array by removing it, shifting all other elements left, and reducing the array size.

Execution Sample

DSA Go

arr := []int{10, 20, 30, 40, 50}
// Delete first element
for i := 1; i < len(arr); i++ {
    arr[i-1] = arr[i]
}
arr = arr[:len(arr)-1]

This code deletes the first element of an integer array by shifting elements left and slicing the array.

Execution Table

Step	Operation	Array State	Pointer Changes	Visual State
0	Start with array	[10, 20, 30, 40, 50]	head=0, tail=4	10 -> 20 -> 30 -> 40 -> 50 -> null
1	Shift element at index 1 to index 0	[20, 20, 30, 40, 50]	head=0, tail=4	20 -> 20 -> 30 -> 40 -> 50 -> null
2	Shift element at index 2 to index 1	[20, 30, 30, 40, 50]	head=0, tail=4	20 -> 30 -> 30 -> 40 -> 50 -> null
3	Shift element at index 3 to index 2	[20, 30, 40, 40, 50]	head=0, tail=4	20 -> 30 -> 40 -> 40 -> 50 -> null
4	Shift element at index 4 to index 3	[20, 30, 40, 50, 50]	head=0, tail=4	20 -> 30 -> 40 -> 50 -> 50 -> null
5	Reduce array size by 1 (remove last duplicate)	[20, 30, 40, 50]	head=0, tail=3	20 -> 30 -> 40 -> 50 -> null
6	End	[20, 30, 40, 50]	head=0, tail=3	20 -> 30 -> 40 -> 50 -> null

💡 Array size reduced by 1, first element deleted, shifting complete.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	After Step 5	Final
arr	[10,20,30,40,50]	[20,20,30,40,50]	[20,30,30,40,50]	[20,30,40,40,50]	[20,30,40,50,50]	[20,30,40,50]	[20,30,40,50]
head	0	0	0	0	0	0	0
tail	4	4	4	4	4	3	3
length	5	5	5	5	5	4	4

Key Moments - 3 Insights

Why do we shift elements left instead of just removing the first element?

Because arrays have fixed positions, removing the first element leaves a gap. Shifting left fills that gap and keeps elements contiguous, as shown in steps 1 to 4 in the execution_table.

Why do we reduce the array size after shifting?

After shifting, the last element is duplicated. Reducing the size removes this duplicate, shown in step 5, so the array length matches the new content.

What happens if the array is empty before deletion?

If empty, no shifting or size reduction happens. The code would skip the loop and slicing, preventing errors. This is implied by the exit condition in the code.

Visual Quiz - 3 Questions

Look at the execution_table at step 3, what is the array state?

A [20, 20, 30, 40, 50]

B [10, 20, 30, 40, 50]

C [20, 30, 40, 40, 50]

D [20, 30, 30, 40, 50]

💡 Hint

Check the 'Array State' column at step 3 in the execution_table.

At which step does the array size reduce?

A Step 4

B Step 5

C Step 6

D Step 2

💡 Hint

Look for 'Reduce array size' operation in the execution_table.

If we skip shifting elements, what would the final array look like?

A [, 20, 30, 40, 50]

B [20, 30, 40, 50]

C [10, 20, 30, 40]

D [10, 20, 30, 40, 50]

💡 Hint

Without shifting, the first element remains but logically removed, leaving a gap at index 0.

Concept Snapshot

Array Deletion at Beginning:
- Remove first element by shifting all elements left by one.
- Overwrite element at i-1 with element at i.
- Reduce array size by slicing off last element.
- Keeps array contiguous and size correct.
- Common in fixed-size arrays without built-in removal.

Full Transcript

This visual execution shows how to delete the first element of an array by shifting all elements left and reducing the array size. Starting with [10, 20, 30, 40, 50], each element from index 1 to end moves one position left, overwriting the previous element. After shifting, the last element is duplicated, so the array size is reduced by one to remove the duplicate. The final array is [20, 30, 40, 50]. Variables like head and tail pointers remain to track array bounds. Key moments include why shifting is necessary to avoid gaps and why size reduction is needed to remove duplicates. The quiz tests understanding of array states at different steps and consequences of skipping shifting.

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