Array Insertion at Beginning in DSA Go - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output after inserting elements at the beginning of an array

What is the output of the following Go code that inserts elements at the beginning of a slice?

DSA Go

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

A [2 1 3 4 5]

B [3 4 5 2 1]

C [5 4 3 2 1]

D [1 2 3 4 5]

💡 Hint

Remember that appending a slice with ... spreads the elements.

The code inserts 2 at the beginning of the slice, then inserts 1 at the beginning again, resulting in [1 2 3 4 5].

❓ Predict Output

intermediate

Resulting slice after multiple insertions at the beginning

What will be printed after running this Go code that inserts multiple elements at the beginning of a slice?

DSA Go

package main
import "fmt"
func main() {
    s := []int{10, 20}
    s = append([]int{5}, s...)
    s = append([]int{1, 2, 3}, s...)
    fmt.Println(s)
}

A [1 2 3 5 10 20]

B [5 1 2 3 10 20]

C [10 20 5 1 2 3]

D [1 2 3 10 20 5]

💡 Hint

Appending slices with ... adds all elements in order.

First 5 is inserted at the beginning, then 1,2,3 are inserted before that, resulting in [1 2 3 5 10 20].

🔧 Debug

advanced

Identify the error in slice insertion at beginning

What error will this Go code produce when trying to insert an element at the beginning of a slice?

DSA Go

package main
import "fmt"
func main() {
    arr := []int{1, 2, 3}
    arr = append(arr, 0)
    copy(arr[1:], arr)
    arr[0] = 9
    fmt.Println(arr)
}

A [9 1 2 3 0]

B runtime error: slice bounds out of range

C [1 2 3 0 9]

D Compilation error: invalid use of copy

💡 Hint

Check how copy is used and the slice lengths involved.

The copy call tries to copy arr onto arr[1:], but arr[1:] is shorter than arr, causing out of range runtime error.

🧠 Conceptual

advanced

Time complexity of inserting at the beginning of an array

What is the time complexity of inserting an element at the beginning of a dynamic array (slice) in Go?

A O(1), because slices support fast prepend

B O(n^2), because each insertion copies the entire array twice

C O(n), because all elements must be shifted right

D O(log n), due to internal resizing

💡 Hint

Think about what happens to existing elements when inserting at the start.

Inserting at the beginning requires shifting all existing elements one position right, which takes O(n) time.

🚀 Application

expert

Efficiently insert multiple elements at the beginning of a slice

Given a slice s := []int{4,5,6} and another slice prefix := []int{1,2,3}, which code snippet correctly and efficiently inserts all elements of prefix at the beginning of s?

A s = append(prefix, s...)

B for i := len(prefix)-1; i >= 0; i-- { s = append([]int{prefix[i]}, s...) }

C copy(s[len(prefix):], s); copy(s, prefix)

D s = append(s, prefix...)

💡 Hint

Appending prefix slice before s with ... spreads all elements.

Appending prefix before s with s = append(prefix, s...) creates a new slice with prefix elements first, then s elements.

Practice

1. What happens when you insert an element at the beginning of an array in Go?

easy

A. The array size decreases by one.

B. The new element replaces the first element without shifting others.

C. All existing elements shift one position to the right to make space.

D. The new element is added at the end of the array.

Solution

1. Step 1: Understand array behavior in Go

   Arrays have fixed size, so to insert at the beginning, elements must shift right.

2. Step 2: Effect of insertion at beginning

   The first element moves to second position, second to third, and so on, making space at index 0.

3. Final Answer:

   All existing elements shift one position to the right to make space. -> Option C

4. Quick Check:

   Insertion at start shifts elements right = A [OK]

Hint: Insertion at start shifts all elements right by one [OK]

Common Mistakes:

• Thinking new element replaces first without shifting
• Assuming array size changes automatically
• Adding element at the end instead of beginning

2. Which of the following Go code snippets correctly inserts an element `x` at the beginning of a slice `s`?

easy

A. s = s[1:]

B. s = append(s, x)

C. s[0] = x

D. s = append([]int{x}, s...)

Solution

1. Step 1: Understand slice append syntax

   Appending a slice to another uses append(slice1, slice2...), so to add at start, prepend with new slice.

2. Step 2: Analyze each option

   s = append([]int{x}, s...) prepends x correctly; B appends at end; C replaces first element; D slices off first element.

3. Final Answer:

   s = append([]int{x}, s...) -> Option D

4. Quick Check:

   Prepend with append([]int{x}, s...) = A [OK]

Hint: Use append with new slice and ... to insert at start [OK]

Common Mistakes:

• Using append(s, x) adds at end, not start
• Replacing element instead of inserting
• Slicing removes elements instead of adding

3. What is the output of this Go code?

package main
import "fmt"
func main() {
  s := []int{2, 3, 4}
  s = append([]int{1}, s...)
  fmt.Println(s)
}

medium

A. [1 2 3 4]

B. [2 3 4 1]

C. [1 3 4]

D. [2 3 4]

Solution

1. Step 1: Initial slice and append operation

   Initial slice s is [2 3 4]. append([]int{1}, s...) adds 1 at start.

2. Step 2: Resulting slice after append

   New slice becomes [1 2 3 4] because 1 is prepended before all elements.

3. Final Answer:

   [1 2 3 4] -> Option A

4. Quick Check:

   Prepending 1 to [2 3 4] = [1 2 3 4] [OK]

Hint: append([]int{x}, s...) prepends x to slice s [OK]

Common Mistakes:

• Thinking append adds at end by default
• Ignoring ... operator to expand slice
• Confusing slice contents after append

4. Identify the error in this Go code that tries to insert 0 at the beginning of slice `s`:

package main
import "fmt"
func main() {
  s := []int{1, 2, 3}
  s[0] = 0
  fmt.Println(s)
}

medium

A. It replaces the first element instead of inserting a new one.

B. It causes a runtime panic due to index out of range.

C. It appends 0 at the end instead of the beginning.

D. It creates a new slice with 0 at the start.

Solution

1. Step 1: Analyze the assignment s[0] = 0

   This replaces the value at index 0 with 0, not inserting a new element.

2. Step 2: Effect on slice length and contents

   Slice length stays same; no shifting occurs; original first element lost.

3. Final Answer:

   It replaces the first element instead of inserting a new one. -> Option A

4. Quick Check:

   Assignment replaces element, does not insert [OK]

Hint: Assignment replaces element; use append to insert [OK]

Common Mistakes:

• Thinking s[0] = 0 inserts element
• Expecting slice length to increase
• Confusing replace with insert

5. Given a slice `s := []int{3, 4, 5}`, write Go code to insert the numbers 1 and 2 at the beginning so that the final slice is `[1 2 3 4 5]`. Which code snippet achieves this correctly?

hard

A. s[0], s[1] = 1, 2

B. s = append([]int{1, 2}, s...)

C. s = append(s[:0], 1, 2)

D. s = append(s, 1, 2)

Solution

1. Step 1: Understand slice prepending with append

   To add multiple elements at start, create a new slice with them and append original slice after.

2. Step 2: Analyze options

   s = append([]int{1, 2}, s...) prepends [1, 2] correctly; A replaces first two elements; B appends at end; C overwrites start without preserving rest.

3. Final Answer:

   s = append([]int{1, 2}, s...) -> Option B

4. Quick Check:

   Prepend multiple elements with append([]int{...}, s...) [OK]

Hint: Use append with slice of new elements and ... to prepend [OK]

Common Mistakes:

• Appending instead of prepending
• Overwriting elements without shifting
• Misusing slice syntax causing data loss