Array Deletion at Middle Index in DSA Go - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does 'Array Deletion at Middle Index' mean?

It means removing an element from the middle position of an array and shifting the remaining elements to fill the gap.

beginner

Why do we need to shift elements after deleting from the middle of an array?

Because arrays have fixed positions, when we remove one element, the rest must move left to keep the array continuous without empty spots.

intermediate

What is the time complexity of deleting an element from the middle of an array?

The time complexity is O(n) because we may need to shift up to n-1 elements after deletion.

intermediate

In Go, which data structure is commonly used to handle dynamic array deletions more efficiently than arrays?

Slices are used in Go because they allow dynamic resizing and easier element removal compared to fixed-size arrays.

beginner

What happens if you try to delete an element at an index outside the array bounds?

It causes a runtime error or panic because the index is invalid and does not exist in the array.

What must you do after deleting an element from the middle of an array?

A Shift all elements after it one position to the left

B Shift all elements before it one position to the right

C Do nothing, the array automatically adjusts

D Replace the deleted element with zero

After deletion, elements to the right must shift left to fill the gap.

What is the main drawback of deleting from the middle of a fixed-size array?

A It causes the array to become unsorted

B It requires shifting elements, which takes time

C It increases the array size

D It duplicates elements

Shifting elements after deletion takes time proportional to the number of elements shifted.

In Go, which type is better for frequent deletions: array or slice?

A Map

B Array

C Slice

D Struct

Slices allow dynamic resizing and easier element removal.

If an array has 5 elements, what is the index of the middle element?

A 2

B 1

C 3

D 4

Indexing starts at 0, so middle is at index 2 for 5 elements.

What happens if you delete an element at index 10 in an array of size 5?

A No effect

B Deletes last element

C Deletes first element

D Error or panic due to invalid index

Index 10 is out of bounds for size 5 array, causing an error.

Explain step-by-step how to delete an element from the middle of an array and maintain the array's order.

Think about how to keep the array continuous without gaps.

Describe the difference between deleting an element from an array versus a slice in Go.

Consider how Go handles memory and size for arrays and slices.

Practice

1. What happens when you delete the middle element from an array with an odd number of elements?

easy

A. The array size stays the same but the middle element becomes zero.

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

C. The array is reversed after deletion.

D. The first element is removed instead of the middle.

Solution

1. Step 1: Understand array deletion

   Deleting an element removes it and shifts later elements left.

2. Step 2: Effect on array size

   Removing one element reduces the array length by one.

3. Final Answer:

   The middle element is removed and the array size decreases by one. -> Option B

4. Quick Check:

   Delete middle element = size - 1 [OK]

Hint: Deleting removes element and shrinks array size [OK]

Common Mistakes:

• Thinking array size stays the same after deletion
• Assuming deletion replaces element with zero
• Confusing middle deletion with first element deletion

2. Which Go code snippet correctly deletes the middle element from an array named arr with odd length?

easy

A. arr = arr[len(arr)/2+1:]

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

C. arr = append(arr[:len(arr)/2], arr[len(arr)/2+1:]...)

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

Solution

1. Step 1: Identify correct slicing syntax

   In Go, to delete an element at index i, use append(arr[:i], arr[i+1:]...).

2. Step 2: Apply to middle index

   Middle index is len(arr)/2 for odd length, so arr = append(arr[:len(arr)/2], arr[len(arr)/2+1:]...).

3. Final Answer:

   arr = append(arr[:len(arr)/2], arr[len(arr)/2+1:]...) -> Option C

4. Quick Check:

   Use append with slices excluding middle [OK]

Hint: Use append(arr[:i], arr[i+1:]...) to delete index i [OK]

Common Mistakes:

• Using + operator to join slices (invalid in Go)
• Not using ... to expand second slice in append
• Deleting wrong index or slice ranges

3. What is the output of this Go code?

arr := []int{10, 20, 30, 40, 50}
mid := len(arr) / 2
arr = append(arr[:mid], arr[mid+1:]...)
fmt.Println(arr)

medium

A. [10 20 40 50]

B. [10 20 30 40]

C. [20 30 40 50]

D. [10 30 40 50]

Solution

1. Step 1: Calculate middle index

   len(arr) = 5, so mid = 5 / 2 = 2 (integer division).

2. Step 2: Delete element at index 2

   Element at index 2 is 30. After deletion, arr = [10, 20] + [40, 50] = [10 20 40 50].

3. Final Answer:

   [10 20 40 50] -> Option A

4. Quick Check:

   Removed 30 at index 2 [OK]

Hint: Middle index = length/2; remove that element [OK]

Common Mistakes:

• Using float division instead of integer
• Deleting wrong index element
• Not expanding slice with ... in append

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

arr := []int{1, 2, 3, 4, 5}
mid := len(arr) / 2
arr = append(arr[:mid], arr[mid:]...)
fmt.Println(arr)

medium

A. The second slice should start from mid+1, not mid.

B. The middle index calculation is wrong.

C. append cannot be used with slices.

D. The array length is even, so no middle element.

Solution

1. Step 1: Check slice ranges in append

   The code uses arr[mid:] which includes the middle element again, not deleting it.

2. Step 2: Correct slice to exclude middle element

   To delete middle element at mid, use arr[mid+1:] to skip it.

3. Final Answer:

   The second slice should start from mid+1, not mid. -> Option A

4. Quick Check:

   Exclude middle element by slicing from mid+1 [OK]

Hint: Second slice must start at mid+1 to delete middle [OK]

Common Mistakes:

• Using arr[mid:] includes middle element again
• Miscalculating middle index for odd length
• Thinking append can't join slices

5. Given an array arr := []int{5, 10, 15, 20, 25, 30, 35}, write the Go code to delete the middle element and then insert 100 at the same middle index. What will be the final array?

hard

A. [5 10 15 20 100 25 30 35]

B. [5 10 15 20 25 30 35 100]

C. [5 10 15 20 25 30 35]

D. [5 10 15 100 25 30 35]

Solution

1. Step 1: Delete middle element

   Length is 7, middle index = 7/2 = 3. Delete element at index 3 (value 20): arr = append(arr[:3], arr[4:]...) = [5 10 15 25 30 35].

2. Step 2: Insert 100 at middle index

   Insert 100 at index 3: arr = append(arr[:3], append([]int{100}, arr[3:]...)...) = [5 10 15 100 25 30 35].

3. Step 3: Verify final array

   Final array is [5 10 15 100 25 30 35].

4. Final Answer:

   [5 10 15 100 25 30 35] -> Option D

5. Quick Check:

   Delete middle, insert 100 at same index [OK]

Hint: Delete middle then insert at same index using append [OK]

Common Mistakes:

• Not updating array after deletion before insertion
• Inserting 100 at wrong index
• Appending 100 at end instead of middle