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

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output after inserting at the beginning?

Consider an array of integers initially containing [10, 20, 30, 40]. We insert the value 5 at the beginning by shifting elements to the right. What is the final array?

DSA C

int arr[5] = {10, 20, 30, 40};
int n = 4;
int x = 5;
for (int i = n; i > 0; i--) {
    arr[i] = arr[i-1];
}
arr[0] = x;
n++;
for (int i = 0; i < n; i++) {
    printf("%d ", arr[i]);
}

A [5, 20, 30, 40, 10]

B [10, 5, 20, 30, 40]

C [5, 10, 20, 30, 40]

D [10, 20, 30, 40, 5]

💡 Hint

Think about shifting elements from the end towards the beginning before inserting.

To insert at the beginning, all elements must move one position right. Then the new element is placed at index 0.

🧠 Conceptual

intermediate

Why do we shift elements when inserting at the beginning?

When inserting a new element at the start of a fixed-size array, why is it necessary to shift existing elements to the right?

A To sort the array automatically after insertion.

B To make space at the beginning without losing existing elements.

C To remove duplicates from the array.

D To reverse the array order.

💡 Hint

Think about what happens if you put a new element at index 0 without moving others.

Shifting elements right creates an empty slot at index 0 so the new element can be inserted without overwriting existing data.

🔧 Debug

advanced

Find the error in this insertion code

This code attempts to insert 99 at the beginning of an array but produces wrong output. What is the error?

DSA C

int arr[5] = {1, 2, 3, 4};
int n = 4;
int x = 99;
for (int i = 0; i < n; i++) {
    arr[i+1] = arr[i];
}
arr[0] = x;
n++;
for (int i = 0; i < n; i++) {
    printf("%d ", arr[i]);
}

A The loop should run backwards from n to 0 to avoid overwriting elements.

B The array size is too small to hold the new element.

C The value x should be assigned after the loop ends.

D The loop condition should be i <= n instead of i < n.

💡 Hint

Consider what happens when you move elements forward starting from the beginning.

Shifting elements forward from the start overwrites data before it is copied. Looping backwards preserves data during shifting.

❓ Predict Output

advanced

Output after multiple insertions at beginning

Starting with an empty array of size 5, insert 3, then 7, then 1 at the beginning in that order. What is the final array?

DSA C

int arr[5];
int n = 0;
int values[] = {3, 7, 1};
for (int k = 0; k < 3; k++) {
    for (int i = n; i > 0; i--) {
        arr[i] = arr[i-1];
    }
    arr[0] = values[k];
    n++;
}
for (int i = 0; i < n; i++) {
    printf("%d ", arr[i]);
}

A [1, 7, 3]

B [3, 7, 1]

C [7, 3, 1]

D [1, 3, 7]

💡 Hint

Each new element goes to index 0, pushing others right.

Insert 3: [3] Insert 7: [7, 3] Insert 1: [1, 7, 3]

🧠 Conceptual

expert

Why is inserting at the beginning of an array costly?

Inserting an element at the beginning of a large fixed-size array requires shifting all elements. Why is this operation considered costly in terms of performance?

A Because inserting at the beginning causes the array to resize automatically.

B Because arrays cannot store elements at the beginning.

C Because the first element is always locked and cannot be changed.

D Because shifting elements requires moving many items, which takes time proportional to the array size.

💡 Hint

Think about how many elements must be moved when inserting at the start.

Each insertion at the beginning requires moving all existing elements one position right, which takes time proportional to the number of elements.

Practice

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

easy

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

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

C. The array size automatically increases without shifting elements.

D. The last element is removed to insert the new element at the start.

Solution

1. Step 1: Understand array memory layout

   Arrays store elements in continuous memory. To insert at the start, existing elements must move to free space.

2. Step 2: Shift elements to the right

   Each element moves one position right to open index 0 for the new element.

3. Final Answer:

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

4. Quick Check:

   Insert at start = shift right [OK]

Hint: Insert at start means shift all elements right [OK]

Common Mistakes:

• Assuming new element overwrites first element
• Thinking array size grows automatically
• Removing last element without reason

2. Which of the following is the correct syntax to insert an element at the beginning of an array in C (assuming space is available)?

easy

A. arr[0] = new_element; for(int i = 1; i <= n; i++) arr[i] = arr[i-1];

B. for(int i = 0; i < n; i++) arr[i+1] = arr[i]; arr[0] = new_element;

C. for(int i = n; i > 0; i--) arr[i] = arr[i-1]; arr[0] = new_element;

D. arr[n] = new_element; for(int i = n-1; i >= 0; i--) arr[i] = arr[i+1];

Solution

1. Step 1: Identify correct loop direction for shifting

   To avoid overwriting, shift elements from end to start (i = n down to 1).

2. Step 2: Assign new element at index 0

   After shifting, place new_element at arr[0].

3. Final Answer:

   for(int i = n; i > 0; i--) arr[i] = arr[i-1]; arr[0] = new_element; -> Option C

4. Quick Check:

   Shift right from end, then insert [OK]

Hint: Shift from end to start to avoid overwrite [OK]

Common Mistakes:

• Shifting from start to end causing overwrite
• Assigning new element before shifting
• Incorrect loop boundaries

3. What will be the content of the array after executing this code?

int arr[5] = {10, 20, 30, 40, 0};
int n = 4;
int new_element = 5;
for(int i = n; i > 0; i--) {
  arr[i] = arr[i-1];
}
arr[0] = new_element;

medium

A. [0, 10, 20, 30, 40]

B. [10, 5, 20, 30, 40]

C. [5, 10, 20, 30, 0]

D. [5, 10, 20, 30, 40]

Solution

1. Step 1: Shift elements right from index 4 to 1

   arr[4]=arr[3]=40, arr[3]=arr[2]=30, arr[2]=arr[1]=20, arr[1]=arr[0]=10

2. Step 2: Insert new_element at arr[0]

   arr[0] = 5

3. Final Answer:

   [5, 10, 20, 30, 40] -> Option D

4. Quick Check:

   Shift right + insert 5 at start = [5,10,20,30,40] [OK]

Hint: Trace shifts from end, then insert new element at start [OK]

Common Mistakes:

• Not shifting last element correctly
• Overwriting elements during shift
• Forgetting to insert new element at index 0

4. Identify the error in this code snippet that tries to insert an element at the beginning of an array:

int arr[5] = {1, 2, 3, 4, 0};
int n = 4;
int new_element = 0;
for(int i = 0; i < n; i++) {
  arr[i+1] = arr[i];
}
arr[0] = new_element;

medium

A. Loop direction causes overwriting of elements during shift.

B. Array size is too small to insert new element.

C. New element is assigned after shifting elements.

D. Loop condition should be i <= n instead of i < n.

Solution

1. Step 1: Analyze loop direction and assignments

   Loop shifts elements from start to end, causing arr[i+1] to overwrite arr[i+1] before it is copied.

2. Step 2: Correct approach is to shift from end to start

   Shifting from end to start prevents overwriting original values during shift.

3. Final Answer:

   Loop direction causes overwriting of elements during shift. -> Option A

4. Quick Check:

   Shift must go backward to avoid overwrite [OK]

Hint: Shift elements backward to avoid overwriting [OK]

Common Mistakes:

• Shifting forward overwrites data
• Ignoring array size limits
• Incorrect loop boundaries

5. Given an array int arr[7] = {2, 4, 6, 8, 10, 0, 0}; with n = 5 elements, write the steps to insert 1 at the beginning and then 0 at the beginning again. What will be the final array content?

hard

A. [0, 1, 2, 4, 6, 8, 10]

B. [0, 1, 2, 4, 6, 8]

C. [0, 1, 2, 4, 6, 8, 10, 0]

D. [1, 0, 2, 4, 6, 8]

Solution

1. Step 1: Insert 1 at beginning

   Shift elements right: arr[5]=arr[4]=10, arr[4]=arr[3]=8, arr[3]=arr[2]=6, arr[2]=arr[1]=4, arr[1]=arr[0]=2; then arr[0]=1. Array: [1, 2, 4, 6, 8, 10]

2. Step 2: Insert 0 at beginning

   Shift elements right again: arr[6]=arr[5]=10, arr[5]=arr[4]=8, arr[4]=arr[3]=6, arr[3]=arr[2]=4, arr[2]=arr[1]=2, arr[1]=arr[0]=1; then arr[0]=0. Array: [0, 1, 2, 4, 6, 8, 10]

3. Final Answer:

   [0, 1, 2, 4, 6, 8, 10] -> Option A

4. Quick Check:

   Two shifts + inserts = [0,1,2,4,6,8,10] [OK]

Hint: Shift right twice, insert each new element at index 0 [OK]

Common Mistakes:

• Not updating array size after insertions
• Overwriting elements during second insertion
• Assuming array can hold more than 6 elements