Array Deletion at End in DSA Go - Execution Trace

Concept Flow - Array Deletion at End

Start with array

↓

Check if array is empty?

Yes→Stop: nothing to delete

No↓

Remove last element

↓

Update array size

↓

Done

This flow shows checking if the array is empty, then removing the last element and updating the size.

Execution Sample

DSA Go

package main

import "fmt"

func main() {
    arr := []int{10, 20, 30, 40}
    if len(arr) > 0 {
        arr = arr[:len(arr)-1]
    }
    fmt.Println(arr)
}

This code removes the last element from the array if it is not empty and prints the updated array.

Execution Table

Step	Operation	Array Before	Array After	Array Length Before	Array Length After	Visual State
1	Start with array	[10, 20, 30, 40]	[10, 20, 30, 40]	4	4	10 -> 20 -> 30 -> 40 -> null
2	Check if array is empty	[10, 20, 30, 40]	[10, 20, 30, 40]	4	4	Array not empty, proceed
3	Remove last element	[10, 20, 30, 40]	[10, 20, 30]	4	3	10 -> 20 -> 30 -> null
4	Print updated array	[10, 20, 30]	[10, 20, 30]	3	3	10 -> 20 -> 30 -> null
5	End	[10, 20, 30]	[10, 20, 30]	3	3	Deletion complete

💡 Array length reduced by 1 after removing last element

Variable Tracker

Variable	Start	After Step 3	Final
arr	[10, 20, 30, 40]	[10, 20, 30]	[10, 20, 30]
len(arr)	4	3	3

Key Moments - 3 Insights

Why do we check if the array is empty before deleting?

Because deleting from an empty array would cause an error. As shown in step 2 of the execution_table, we only proceed if the array length is greater than zero.

Does the original array memory shrink after deletion?

In Go slices, the underlying array may still hold the old elements, but the slice length is reduced. The visual state in step 3 shows the slice now only includes the first three elements.

What happens if we try to delete without slicing?

Without slicing, the array remains unchanged. The deletion happens by creating a new slice excluding the last element, as in step 3.

Visual Quiz - 3 Questions

Look at the execution_table, what is the length of arr after step 3?

A 3

B 4

C 0

D 1

💡 Hint

Check the 'Array Length After' column in step 3 of the execution_table.

At which step does the array actually lose its last element?

A Step 4

B Step 2

C Step 3

D Step 1

💡 Hint

Look at the 'Operation' and 'Array After' columns to see when the array changes.

If the array was empty at start, what would happen at step 2?

A Proceed to remove last element

B Stop deletion process

C Print empty array and continue

D Throw runtime error

💡 Hint

Refer to the concept_flow and step 2 in execution_table about empty array check.

Concept Snapshot

Array Deletion at End:
- Check if array is empty
- Remove last element by slicing: arr = arr[:len(arr)-1]
- Length reduces by 1
- Underlying array may still hold old data
- Safe deletion avoids errors on empty arrays

Full Transcript

This visual trace shows how to delete the last element from an array in Go. We start with an array of four elements. First, we check if the array is empty to avoid errors. Since it is not empty, we remove the last element by slicing the array up to length minus one. The array length reduces from 4 to 3. The visual state updates to show the new array without the last element. Finally, we print the updated array. This process safely deletes the last element without causing runtime errors.

Practice

1. What happens when you delete an element from the end of an array in Go?

easy

A. The last element is removed and the array size decreases by one.

B. The first element is removed and the array size decreases by one.

C. The array size stays the same but the last element becomes zero.

D. The array is completely cleared and becomes empty.

Solution

1. Step 1: Understand array deletion at end

   Deleting at the end means removing the last element only, not the first or all.

2. Step 2: Effect on array size

   After removal, the array size decreases by one because one element is gone.

3. Final Answer:

   The last element is removed and the array size decreases by one. -> Option A

4. Quick Check:

   Deleting end element reduces size by one [OK]

Hint: Deleting at end removes last element and shrinks array [OK]

Common Mistakes:

• Thinking first element is removed
• Assuming array size stays same
• Believing array clears completely

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

easy

A. arr = arr[len(arr):]

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

C. arr = arr[1:]

D. arr = arr[:len(arr)+1]

Solution

1. Step 1: Understand slice slicing syntax

   To remove last element, slice up to length minus one: arr[:len(arr)-1].

2. Step 2: Check other options

   arr[len(arr):] results in empty slice, arr[1:] removes first element, arr[:len(arr)+1] causes runtime error.

3. Final Answer:

   arr = arr[:len(arr)-1] -> Option B

4. Quick Check:

   Slice up to len-1 removes last element [OK]

Hint: Use arr[:len(arr)-1] to drop last element [OK]

Common Mistakes:

• Using arr[1:] removes first element
• Using arr[len(arr):] gives empty slice
• Using arr[:len(arr)+1] causes error

3. What is the output of this Go code?

arr := []int{10, 20, 30, 40}
arr = arr[:len(arr)-1]
fmt.Println(arr)

medium

A. [10 20 30 40]

B. []

C. [10 20 30]

D. [20 30 40]

Solution

1. Step 1: Initial array and slicing

   arr starts as [10 20 30 40]. Slicing arr[:len(arr)-1] means arr[:3].

2. Step 2: Result after slicing

   arr[:3] gives first three elements: [10 20 30].

3. Final Answer:

   [10 20 30] -> Option C

4. Quick Check:

   Slice up to len-1 excludes last element [OK]

Hint: Slicing arr[:len(arr)-1] drops last element [OK]

Common Mistakes:

• Expecting last element to remain
• Confusing arr[1:] with arr[:len(arr)-1]
• Thinking output is empty slice

4. Identify the error in this Go code that tries to delete the last element from arr:

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

medium

A. It deletes all elements making the array empty.

B. It causes a runtime panic due to invalid slice bounds.

C. It deletes the first element instead of the last.

D. It does not delete any element; array remains unchanged.

Solution

1. Step 1: Analyze slicing bounds

   arr[:len(arr)] means slice from start to full length, so no element is removed.

2. Step 2: Effect on array

   Since slice covers entire array, arr remains [1 2 3] unchanged.

3. Final Answer:

   It does not delete any element; array remains unchanged. -> Option D

4. Quick Check:

   Slicing arr[:len(arr)] keeps full array [OK]

Hint: arr[:len(arr)] keeps full array, no deletion [OK]

Common Mistakes:

• Assuming last element is deleted
• Expecting runtime error
• Thinking first element is removed

5. Given a slice arr := []int{5, 10, 15, 20, 25}, write the Go code to delete the last two elements and print the resulting slice.

hard

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

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

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

D. arr = arr[1:len(arr)-1]
fmt.Println(arr)

Solution

1. Step 1: Understand deletion of last two elements

   To remove last two elements, slice up to length minus two: arr[:len(arr)-2].

2. Step 2: Apply slicing and print

   arr[:3] gives [5 10 15]. Printing arr shows these three elements.

3. Final Answer:

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

4. Quick Check:

   Slice up to len-2 removes last two elements [OK]

Hint: Use arr[:len(arr)-2] to remove last two elements [OK]

Common Mistakes:

• Using arr[2:] removes first two elements
• Removing only last element instead of two
• Incorrect slice bounds causing errors