Array Insertion at Beginning in DSA Go

Mental Model

To insert a new item at the start of an array, we must move all existing items one step to the right to make space.

Analogy: Imagine a row of chairs where a new person wants to sit at the first chair, so everyone else must stand up and move one chair to the right to make room.

Index: 0   1   2   3   4
Array: [1]->[2]->[3]->[4]->[5]

Dry Run Walkthrough

Input: array: [1, 2, 3, 4, 5], insert value 0 at beginning

Goal: Insert 0 at the start, shifting all elements right

Step 1: Shift element at index 4 (5) to index 5

[1]->[2]->[3]->[4]->[5]->[5]

Why: Make space at the end to avoid overwriting data

Step 2: Shift element at index 3 (4) to index 4

[1]->[2]->[3]->[4]->[4]->[5]

Why: Move elements right one by one to free index 0

Step 3: Shift element at index 2 (3) to index 3

[1]->[2]->[3]->[3]->[4]->[5]

Why: Continue shifting elements right

Step 4: Shift element at index 1 (2) to index 2

[1]->[2]->[2]->[3]->[4]->[5]

Why: Keep shifting to free index 0

Step 5: Shift element at index 0 (1) to index 1

[1]->[1]->[2]->[3]->[4]->[5]

Why: Final shift to free first position

Step 6: Insert new value 0 at index 0

[0]->[1]->[2]->[3]->[4]->[5]

Why: Place new element at the beginning

Result:

[0]->[1]->[2]->[3]->[4]->[5]

Annotated Code

DSA Go

package main

import "fmt"

func insertAtBeginning(arr []int, val int) []int {
	// Create new array with one extra space
	newArr := make([]int, len(arr)+1)
	// Shift elements right by one
	for i := len(arr) - 1; i >= 0; i-- {
		newArr[i+1] = arr[i] // move element to right
	}
	// Insert new value at start
	newArr[0] = val
	return newArr
}

func main() {
	arr := []int{1, 2, 3, 4, 5}
	newArr := insertAtBeginning(arr, 0)
	for i, v := range newArr {
		if i < len(newArr)-1 {
			fmt.Printf("[%d]->", v)
		} else {
			fmt.Printf("[%d]", v)
		}
	}
	fmt.Println()
}

for i := len(arr) - 1; i >= 0; i-- {

iterate backward to shift elements right without overwriting

newArr[i+1] = arr[i] // move element to right

shift each element one position right

newArr[0] = val

insert new value at the beginning

Output

[0]->[1]->[2]->[3]->[4]->[5]

Complexity Analysis

Time: O(n) because we must move all n elements one step to the right

Space: O(n) because we create a new array with one extra space

vs Alternative: In-place shifting is possible but costly; creating a new array is simpler and safer in Go

Edge Cases

empty array

returns a new array with just the inserted element

DSA Go

newArr := make([]int, len(arr)+1)

single element array

shifts the single element right and inserts new at start

DSA Go

for i := len(arr) - 1; i >= 0; i-- {

When to Use This Pattern

When you need to add an element at the start of a fixed-size list, think about shifting elements right or creating a new array with space.

Common Mistakes

Mistake: Shifting elements left to right causing overwriting of data
Fix: Shift elements from right to left (backwards) to avoid overwriting

Summary

Inserts a new element at the start by shifting all existing elements right.

Use when you want to add an item at the beginning of an array.

Shift elements backward to avoid overwriting, then place new element at index zero.

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