Array Insertion at Beginning in DSA Go - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to insert an element at the beginning of the slice.

DSA Go

arr := []int{2, 3, 4}
newElement := 1
arr = append([]int{newElement}, arr[1])
fmt.Println(arr)

Drag options to blanks, or click blank then click option'

A[:]

B[0]

C...

D,

Attempts:

3 left

💡 Hint

Common Mistakes

Forgetting to use '...' causes a nested slice instead of a flat slice.

Appending without '...' results in a nested slice.

The append function in Go can add elements to a slice. To insert at the beginning, we append the original slice after the new element slice using '...'.

2fill in blank

medium

Complete the code to shift elements right before inserting at the beginning.

DSA Go

arr := []int{2, 3, 4}
arr = append(arr, 0)
copy(arr[1:], arr[[1]:])
arr[0] = 1
fmt.Println(arr)

Drag options to blanks, or click blank then click option'

A2

B0

C1

D3

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong start index in copy causes data overwrite or missing elements.

Not appending extra space before copying causes out-of-range errors.

To shift elements right, copy from index 0 to index 1 onwards. So, copy(arr[1:], arr[0:]) shifts all elements right by one.

3fill in blank

hard

Fix the error in the code to insert at the beginning without losing elements.

DSA Go

arr := []int{2, 3, 4}
arr = append(arr, 0)
copy(arr[1:], arr[[1]:])
arr[0] = 1
fmt.Println(arr)

Drag options to blanks, or click blank then click option'

A0

B1

C2

D3

Attempts:

3 left

💡 Hint

Common Mistakes

Starting copy from index 1 causes the first element to be lost.

Not appending space before copy causes runtime panic.

The copy must start from index 0 to shift all elements right. Using 1 or other indices skips elements or causes errors.

4fill in blank

hard

Fill both blanks to create a function that inserts an element at the beginning of a slice.

DSA Go

func insertAtBeginning(arr []int, val int) []int {
	arr = append(arr, 0)
	copy(arr[[1]:], arr[[2]:])
	arr[0] = val
	return arr
}

fmt.Println(insertAtBeginning([]int{2,3,4}, 1))

Drag options to blanks, or click blank then click option'

A1

B0

C2

D3

Attempts:

3 left

💡 Hint

Common Mistakes

Swapping source and destination indices causes incorrect shifting.

Using wrong indices causes data loss or runtime errors.

To shift elements right, copy from index 0 to index 1 onwards. So, copy(arr[1:], arr[0:]) shifts all elements right by one.

5fill in blank

hard

Fill all three blanks to create a function that inserts multiple elements at the beginning of a slice.

DSA Go

func insertMultipleAtBeginning(arr []int, vals []int) []int {
	arr = append(arr, make([]int, len(vals))...)
	copy(arr[[1]:], arr[[2]:])
	copy(arr[0:], vals[[3]:])
	return arr
}

fmt.Println(insertMultipleAtBeginning([]int{3,4,5}, []int{1,2}))

Drag options to blanks, or click blank then click option'

A2

B0

Clen(vals)

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Not appending enough space for new elements causes overwrite.

Incorrect indices in copy cause data loss or panic.

We append space for vals length, shift original elements right by len(vals), then copy vals starting from index 0.

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