Array Deletion at End in DSA Go

Mental Model

Removing the last item from a list means just ignoring it from now on.

Analogy: Like taking the last book off a shelf, you don't move other books, just leave one less on the shelf.

Index: 0   1   2   3   4
Array: [1] [2] [3] [4] [5]
Length: 5 ↑

Dry Run Walkthrough

Input: array: [1, 2, 3, 4, 5], delete last element

Goal: Remove the last element so array becomes [1, 2, 3, 4]

Step 1: Check if array is empty to avoid error

Index: 0   1   2   3   4
Array: [1] [2] [3] [4] [5]
Length: 5 ↑

Why: We must not delete from an empty array

Step 2: Reduce the length by 1 to ignore last element

Index: 0   1   2   3
Array: [1] [2] [3] [4] [5]
Length: 4 ↑

Why: Shortening length removes last element logically

Step 3: Return the updated array with last element removed

Index: 0   1   2   3
Array: [1] [2] [3] [4]
Length: 4 ↑

Why: Now array behaves as if last element is gone

Result:

Index: 0   1   2   3
Array: [1] [2] [3] [4]
Length: 4 ↑

Annotated Code

DSA Go

package main

import (
	"fmt"
)

// deleteLast removes the last element from the array if not empty
func deleteLast(arr []int) []int {
	if len(arr) == 0 {
		return arr // no deletion if empty
	}
	return arr[:len(arr)-1] // slice to exclude last element
}

func main() {
	arr := []int{1, 2, 3, 4, 5}
	fmt.Println("Before deletion:", arr)
	arr = deleteLast(arr)
	fmt.Println("After deletion:", arr)
}

if len(arr) == 0 {

Check if array is empty to avoid deleting from empty array

return arr[:len(arr)-1]

Create a new slice excluding the last element to delete it

Output

Before deletion: [1 2 3 4 5]

After deletion: [1 2 3 4]

Complexity Analysis

Time: O(1) because slicing just adjusts length without copying elements

Space: O(1) because no new array is created, just a slice view

vs Alternative: Naive approach might copy all elements except last to new array O(n), slicing is faster and uses less memory

Edge Cases

empty array

function returns empty array without error

DSA Go

if len(arr) == 0 {

array with one element

deletion results in empty array

DSA Go

return arr[:len(arr)-1]

When to Use This Pattern

When you need to remove the last item from a list quickly, use array slicing to shorten length without moving elements.

Common Mistakes

Mistake: Trying to delete last element by shifting all elements left
Fix: Use slicing to just reduce length instead of moving elements

Mistake: Not checking for empty array before deletion causing runtime error
Fix: Add length check before slicing

Summary

Deletes the last element from an array by shortening its length.

Use when you want to remove the last item efficiently without rearranging the whole array.

The key is that slicing changes the visible length without moving data.

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