Array Insertion at Middle Index in DSA Go - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output after inserting element in the middle of an array

What is the output of the following Go code that inserts the value 99 into the middle of the array?

DSA Go

package main
import "fmt"
func main() {
    arr := []int{10, 20, 30, 40, 50}
    mid := len(arr) / 2
    arr = append(arr[:mid], append([]int{99}, arr[mid:]...)...)
    fmt.Println(arr)
}

A [10 20 30 40 99 50]

B [10 20 30 99 40 50]

C [10 20 99 30 40 50]

D [99 10 20 30 40 50]

💡 Hint

Remember that the middle index is calculated as length divided by 2, and insertion shifts elements to the right.

The middle index of the array with length 5 is 2. Inserting 99 at index 2 shifts elements from index 2 onwards to the right. The resulting array is [10 20 99 30 40 50].

❓ Predict Output

intermediate

Result of inserting element in even-length array middle

What will be printed after inserting 77 in the middle of this even-length array?

DSA Go

package main
import "fmt"
func main() {
    arr := []int{1, 2, 3, 4, 5, 6}
    mid := len(arr) / 2
    arr = append(arr[:mid], append([]int{77}, arr[mid:]...)...)
    fmt.Println(arr)
}

A [1 2 3 77 4 5 6]

B [77 1 2 3 4 5 6]

C [1 2 3 4 77 5 6]

D [1 2 77 3 4 5 6]

💡 Hint

For even length, middle index is length/2, so insertion happens before the element at that index.

The array length is 6, so mid = 3. Inserting 77 at index 3 shifts elements from index 3 onwards to the right. Result: [1 2 3 77 4 5 6].

🔧 Debug

advanced

Identify the error in array insertion code

What error does this Go code produce when trying to insert 10 in the middle of the array?

DSA Go

package main
import "fmt"
func main() {
    arr := []int{5, 6, 7}
    mid := len(arr) / 2
    arr = append(arr[:mid], 10, arr[mid:]...)
    fmt.Println(arr)
}

A SyntaxError: cannot use 10 as variadic argument

B TypeError: cannot append int and slice together

C Compile error: cannot use 10 as slice of int

D No error, prints [5 10 6 7]

💡 Hint

The syntax append(slice[:mid], elem, slice[mid:]...) is the standard way to insert a single element in Go.

There is no error. The code correctly inserts 10 at index 1 (mid=1 for length 3) using append(arr[:mid], 10, arr[mid:]...), which unpacks arr[mid:] into individual elements. It prints [5 10 6 7].

❓ Predict Output

advanced

Output after multiple middle insertions in array

What is the final array after inserting 100 and then 200 at the middle index sequentially?

DSA Go

package main
import "fmt"
func main() {
    arr := []int{1, 2, 3, 4}
    mid := len(arr) / 2
    arr = append(arr[:mid], append([]int{100}, arr[mid:]...)...)
    mid = len(arr) / 2
    arr = append(arr[:mid], append([]int{200}, arr[mid:]...)...)
    fmt.Println(arr)
}

A [1 2 200 100 3 4]

B [1 2 100 200 3 4]

C [1 2 100 3 200 4]

D [1 2 3 100 200 4]

💡 Hint

Remember to recalculate the middle index after the first insertion.

After first insertion (mid=2), array is [1 2 100 3 4]. Length 5, mid=2. Inserting 200 at index 2: [1 2] + [200] + [100 3 4] = [1 2 200 100 3 4].

🧠 Conceptual

expert

Effect of middle insertion on array length and indices

If you insert an element at the middle index of an array of length n, which of the following statements is always true?

A The array length remains the same, and the middle element is replaced by the new element.

B The array length increases by 1, and elements from the middle index onwards shift right by one position.

C The array length decreases by 1, as the middle element is removed and replaced.

D The array length doubles, as elements are duplicated around the middle.

💡 Hint

Think about what happens when you insert an element in the middle of a list.

Inserting an element adds one new element, increasing length by 1. Elements at and after the insertion index move one position to the right.

Practice

1. What is the middle index of an array with 7 elements when inserting a new element?

easy

A. 3

B. 4

C. 2

D. 5

Solution

1. Step 1: Calculate middle index for odd length array

   For an array of length 7, middle index = length / 2 = 7 / 2 = 3 (integer division).

2. Step 2: Confirm insertion position

   The new element should be inserted at index 3 to be in the middle.

3. Final Answer:

   3 -> Option A

4. Quick Check:

   Middle index = 7/2 = 3 [OK]

Hint: Middle index = length divided by 2 (integer division) [OK]

Common Mistakes:

• Using length/2 + 1 for middle index
• Confusing zero-based index with count
• Using length/2 as float instead of integer

2. Which Go code snippet correctly inserts an element `x` at the middle index of slice `arr`?

easy

A. arr = append(arr, x)

B. arr = append(arr[:len(arr)/2], append([]int{x}, arr[len(arr)/2:]...)...)

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

D. arr = append(arr[:len(arr)/2+1], append([]int{x}, arr[len(arr)/2:]...)...)

Solution

1. Step 1: Understand slice insertion in Go

   To insert at middle, split slice at middle index, append new element slice, then append remaining slice.

2. Step 2: Check syntax correctness

   arr = append(arr[:len(arr)/2], append([]int{x}, arr[len(arr)/2:]...)...) correctly uses append with slices and variadic syntax to insert element at middle.

3. Final Answer:

   arr = append(arr[:len(arr)/2], append([]int{x}, arr[len(arr)/2:]...)...) -> Option B

4. Quick Check:

   Correct slice append syntax = arr = append(arr[:len(arr)/2], append([]int{x}, arr[len(arr)/2:]...)...) [OK]

Hint: Use append with slices and variadic ... to insert at middle [OK]

Common Mistakes:

• Trying to append element directly without wrapping in slice
• Incorrect index calculation with +1
• Appending element at end instead of middle

3. What is the output of this Go code?

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

medium

A. [1 2 99 3 4]

B. [1 2 3 99 4]

C. [99 1 2 3 4]

D. [1 2 3 4 99]

Solution

1. Step 1: Calculate middle index

   len(arr) = 4, so mid = 4 / 2 = 2.

2. Step 2: Insert 99 at index 2

   arr[:2] = [1, 2], arr[2:] = [3, 4]. Insert 99 between them.

3. Step 3: Resulting array

   New arr = [1, 2, 99, 3, 4]

4. Final Answer:

   [1 2 99 3 4] -> Option A

5. Quick Check:

   Insert 99 at index 2 = [1 2 99 3 4] [OK]

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

Common Mistakes:

• Inserting element at wrong index
• Appending element at end instead of middle
• Misunderstanding slice append syntax

4. Identify the error in this Go code that tries to insert 50 at the middle of slice `nums`:

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

medium

A. Middle index calculation is wrong

B. Slice nums is not initialized

C. Cannot append element and slice together without wrapping element in slice

D. fmt.Println syntax error

Solution

1. Step 1: Check append syntax

   append(nums[:mid], 50, nums[mid:]...) tries to append int and slice variadically, which is invalid.

2. Step 2: Correct approach

   Wrap 50 in a slice: append(nums[:mid], append([]int{50}, nums[mid:]...)...).

3. Final Answer:

   Cannot append element and slice together without wrapping element in slice -> Option C

4. Quick Check:

   Append element + slice needs nested append [OK]

Hint: Wrap single element in slice when appending with another slice [OK]

Common Mistakes:

• Appending element and slice directly together
• Incorrect middle index calculation
• Forgetting variadic ... operator

5. Given a slice `data := []int{5, 10, 15, 20, 25}`, write the correct Go code to insert `100` exactly in the middle, then print the updated slice.

hard

A. mid := len(data)/2
data = append(data[:mid], 100, data[mid:])
fmt.Println(data)

B. mid := len(data)/2
data = append(data[:mid+1], append([]int{100}, data[mid:]...)...)
fmt.Println(data)

C. mid := len(data)/2
data = append(data, 100)
fmt.Println(data)

D. mid := len(data)/2
data = append(data[:mid], append([]int{100}, data[mid:]...)...)
fmt.Println(data)

Solution

1. Step 1: Calculate middle index

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

2. Step 2: Insert 100 at index 2 correctly

   Use nested append: append(data[:mid], append([]int{100}, data[mid:]...)...).

3. Step 3: Print updated slice

   Prints [5 10 100 15 20 25].

4. Final Answer:

   mid := len(data)/2 data = append(data[:mid], append([]int{100}, data[mid:]...)...) fmt.Println(data) -> Option D

5. Quick Check:

   Insert at middle with nested append = mid := len(data)/2 data = append(data[:mid], append([]int{100}, data[mid:]...)...) fmt.Println(data) [OK]

Hint: Use nested append with slices to insert element at middle [OK]

Common Mistakes:

• Using mid+1 instead of mid for insertion
• Appending element at end instead of middle
• Appending element and slice without wrapping element