Array Deletion at End in DSA Go - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output after deleting the last element from the array?

Consider the following Go code that deletes the last element from an array (slice). What will be printed?

DSA Go

package main
import "fmt"
func main() {
    arr := []int{10, 20, 30, 40, 50}
    arr = arr[:len(arr)-1]
    fmt.Println(arr)
}

A [10 20 30 40]

B [10 20 30 40 50]

C runtime error: slice bounds out of range

D [20 30 40 50]

💡 Hint

Remember that slicing with arr[:len(arr)-1] removes the last element.

The code slices the array to exclude the last element. The original array has 5 elements, and slicing up to len(arr)-1 removes the last one.

❓ Predict Output

intermediate

What happens if we delete the last element from an empty slice?

What will happen when the following Go code runs?

DSA Go

package main
import "fmt"
func main() {
    arr := []int{}
    arr = arr[:len(arr)-1]
    fmt.Println(arr)
}

A runtime error: slice bounds out of range

B nil

C [0]

D []

💡 Hint

Check what len(arr) is when arr is empty and what happens when you subtract 1.

Since the slice is empty, len(arr) is 0. Trying to slice arr[:len(arr)-1] means arr[:-1], which is invalid and causes a runtime error.

🔧 Debug

advanced

Why does this code cause a runtime panic when deleting the last element?

Identify the cause of the runtime panic in this Go code snippet.

DSA Go

package main
import "fmt"
func main() {
    arr := []int{1}
    arr = arr[:len(arr)-2]
    fmt.Println(arr)
}

A The array is empty so slicing is invalid.

B The code tries to delete the first element instead of the last.

C The slice length is not updated after deletion.

D Slicing with len(arr)-2 results in a negative index causing runtime panic.

💡 Hint

Check the value of len(arr)-2 when arr has only one element.

len(arr) is 1, so len(arr)-2 equals -1, which is an invalid slice index causing a runtime panic.

🧠 Conceptual

advanced

What is the time complexity of deleting the last element from a Go slice?

Consider deleting the last element from a slice in Go using slicing. What is the time complexity of this operation?

A O(n) - linear time

B O(log n) - logarithmic time

C O(1) - constant time

D O(n^2) - quadratic time

💡 Hint

Think about whether elements need to be shifted when slicing.

Deleting the last element by slicing does not move elements; it just changes the slice length, so it is constant time.

🚀 Application

expert

After deleting the last element multiple times, what is the final slice?

Given the following Go code, what is the final printed slice?

DSA Go

package main
import "fmt"
func main() {
    arr := []int{5, 10, 15, 20, 25}
    for i := 0; i < 3; i++ {
        arr = arr[:len(arr)-1]
    }
    fmt.Println(arr)
}

A [5 10 15]

B [5 10]

C [5 10 15 20]

D [10 15 20]

💡 Hint

Each iteration removes one element from the end. Count carefully.

The loop runs 3 times, each time removing the last element. Starting with 5 elements, after 3 removals, 2 remain.

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