Array Insertion at Beginning in DSA Go - Execution Trace

Concept Flow - Array Insertion at Beginning

Start with array

↓

Create space at index 0

↓

Shift all elements right by 1

↓

Insert new element at index 0

↓

Array updated with new element at start

The flow shows how to insert a new element at the start by shifting all existing elements one position to the right, then placing the new element at index 0.

Execution Sample

DSA Go

arr := []int{10, 20, 30}
newVal := 5
arr = append(arr, 0)
// Shift elements right
for i := len(arr)-2; i >= 0; i-- {
    arr[i+1] = arr[i]
}
arr[0] = newVal

This code inserts 5 at the beginning of the array by shifting elements right.

Execution Table

Step	Operation	Array	Index Changes	Visual State
0	Start with array	[10, 20, 30, _]	Initial state	10 -> 20 -> 30 -> _
1	Shift element at index 2 to index 3	[10, 20, 30, 30]	index 3 updated	10 -> 20 -> 30 -> 30
2	Shift element at index 1 to index 2	[10, 20, 20, 30]	index 2 updated	10 -> 20 -> 20 -> 30
3	Shift element at index 0 to index 1	[10, 10, 20, 30]	index 1 updated	10 -> 10 -> 20 -> 30
4	Insert new element 5 at index 0	[5, 10, 20, 30]	index 0 updated	5 -> 10 -> 20 -> 30
5	End of insertion	[5, 10, 20, 30]	No index changes	5 -> 10 -> 20 -> 30

💡 All elements shifted right, new element inserted at index 0

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	Final
arr	[10, 20, 30, _]	[10, 20, 30, 30]	[10, 20, 20, 30]	[10, 10, 20, 30]	[5, 10, 20, 30]	[5, 10, 20, 30]
i	n/a	2	1	0	n/a	n/a

Key Moments - 3 Insights

Why do we shift elements from the end towards the beginning?

Shifting from the end prevents overwriting elements before they are moved, as shown in steps 1 to 3 in the execution_table.

What happens if the array has no extra space at the end?

The code assumes space exists; without it, shifting would overwrite data or cause errors. We must resize or create a bigger array first.

Why do we insert the new element only after shifting all elements?

Because shifting creates space at index 0, so inserting before shifting would overwrite the first element, as shown in step 4.

Visual Quiz - 3 Questions

Look at the execution_table, what is the array state after step 2?

A [5, 10, 20, 30]

B [10, 10, 20, 30]

C [10, 20, 20, 30]

D [10, 20, 30, 30]

💡 Hint

Check the 'Visual State' column for step 2 in execution_table.

At which step is the new element inserted at the beginning?

A Step 1

B Step 4

C Step 3

D Step 5

💡 Hint

Look for the operation mentioning 'Insert new element' in execution_table.

If we did not shift elements before insertion, what would happen to the original first element?

A It would be overwritten by the new element

B It would remain unchanged

C It would move to the end

D It would be deleted automatically

💡 Hint

Refer to key_moments about why shifting is necessary before insertion.

Concept Snapshot

Array Insertion at Beginning:
- Shift all elements right by one position starting from the end
- Insert new element at index 0
- Requires extra space at the end
- Prevents overwriting by shifting backwards
- Final array has new element at start

Full Transcript

To insert an element at the beginning of an array, we first shift all existing elements one position to the right starting from the last element. This prevents overwriting data. After shifting, we place the new element at index 0. This process requires that the array has extra space at the end to accommodate the shift. The execution steps show the array state after each shift and the final insertion.

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