Array Deletion at Beginning in DSA Java - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output after deleting first element from array

What is the output of the following Java code that deletes the first element from an array and shifts the remaining elements left?

DSA Java

public class Main {
    public static void main(String[] args) {
        int[] arr = {10, 20, 30, 40, 50};
        int n = arr.length;
        for (int i = 1; i < n; i++) {
            arr[i - 1] = arr[i];
        }
        n = n - 1;
        for (int i = 0; i < n; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

A 20 30 40 50 0

B 20 30 40 50

C 30 40 50

D 10 20 30 40 50

💡 Hint

Focus on how elements are shifted and the new length after deletion.

The code shifts all elements one position to the left, overwriting the first element. The length is reduced by one, so the last element is not printed. The output is the array without the first element: 20 30 40 50.

❓ Predict Output

intermediate

Resulting array after deleting first element and printing full length

What will be printed by this Java code that deletes the first element but prints the entire array length?

DSA Java

public class Main {
    public static void main(String[] args) {
        int[] arr = {5, 15, 25, 35};
        int n = arr.length;
        for (int i = 1; i < n; i++) {
            arr[i - 1] = arr[i];
        }
        n = n - 1;
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

A 15 25 35 35

B 15 25 35 0

C 5 15 25 35

D 25 35 0 0

💡 Hint

Notice the loop prints the original array length, not the reduced length.

The elements are shifted left, so arr becomes [15, 25, 35, 35]. The last element is not cleared, so it remains 35. Printing full length shows 15 25 35 35.

🧠 Conceptual

advanced

Time complexity of deleting first element in array

What is the time complexity of deleting the first element from an array by shifting all elements one position to the left?

A O(1) - Constant time

B O(log n) - Logarithmic time

C O(n^2) - Quadratic time

D O(n) - Linear time

💡 Hint

Consider how many elements need to be moved when deleting the first element.

Deleting the first element requires shifting all remaining elements one position left, which takes time proportional to the number of elements, so O(n).

🔧 Debug

advanced

Identify the error in array deletion code

What error will this Java code produce when deleting the first element from an array?

DSA Java

public class Main {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) {
            arr[i] = arr[i + 1];
        }
        n = n - 1;
        for (int i = 0; i < n; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

A NullPointerException

B No error, prints: 2 3

C ArrayIndexOutOfBoundsException

D SyntaxError

💡 Hint

Check the loop boundary when accessing arr[i + 1].

The loop runs from i=0 to i=2 (n=3), so at i=2 it tries to access arr[3], which is out of bounds, causing ArrayIndexOutOfBoundsException.

🚀 Application

expert

Efficient data structure for frequent deletions at beginning

If you need to delete the first element frequently from a collection, which data structure is best to use for efficient deletions?

A Linked List

B Array (fixed size)

C Stack

D Binary Search Tree

💡 Hint

Consider which structure allows O(1) deletion at the front without shifting elements.

Linked lists allow deletion of the first element in O(1) time by adjusting the head pointer, unlike arrays which require shifting elements.

Practice

1. What happens to the elements of an array when you delete the first element (at the beginning)?

easy

A. All elements shift one position to the left, and the first element is removed.

B. All elements shift one position to the right, and the last element is removed.

C. The array size increases by one.

D. The array remains unchanged.

Solution

1. Step 1: Understand array deletion at beginning

   Deleting the first element means removing the element at index 0.

2. Step 2: Effect on remaining elements

   All other elements move one position left to fill the gap, reducing the array size by one.

3. Final Answer:

   All elements shift one position to the left, and the first element is removed. -> Option A

4. Quick Check:

   Delete first element = shift left [OK]

Hint: Deleting first element shifts all others left by one [OK]

Common Mistakes:

• Thinking elements shift right instead of left
• Assuming array size stays the same
• Believing the array remains unchanged

2. Which of the following Java code snippets correctly deletes the first element from an integer array arr and shifts the remaining elements left?

easy

A. for (int i = 1; i < arr.length; i++) { arr[i] = arr[i - 1]; }

B. for (int i = arr.length - 1; i > 0; i--) { arr[i] = arr[i - 1]; }

C. for (int i = 0; i < arr.length - 1; i++) { arr[i] = arr[i + 1]; }

D. for (int i = 0; i < arr.length; i++) { arr[i + 1] = arr[i]; }

Solution

1. Step 1: Identify correct loop direction and indices

   To shift elements left, start from index 0 to length-2, assigning arr[i] = arr[i+1].

2. Step 2: Check each option

   for (int i = 0; i < arr.length - 1; i++) { arr[i] = arr[i + 1]; } matches this logic; others shift right or use wrong indices causing errors.

3. Final Answer:

   for (int i = 0; i < arr.length - 1; i++) { arr[i] = arr[i + 1]; } -> Option C

4. Quick Check:

   Shift left loop: i from 0 to length-2 [OK]

Hint: Shift left by copying arr[i+1] to arr[i] in forward loop [OK]

Common Mistakes:

• Looping backwards when shifting left
• Using wrong indices causing ArrayIndexOutOfBounds
• Assigning arr[i-1] instead of arr[i+1]

3. What is the output of the following Java code?

int[] arr = {10, 20, 30, 40, 50};
for (int i = 0; i < arr.length - 1; i++) {
    arr[i] = arr[i + 1];
}
arr[arr.length - 1] = 0;
for (int num : arr) {
    System.out.print(num + " ");
}

medium

A. 20 30 40 50 0

B. 10 20 30 40 50

C. 0 10 20 30 40

D. 50 40 30 20 10

Solution

1. Step 1: Trace the shifting loop

   Each element moves left: arr[0]=20, arr[1]=30, arr[2]=40, arr[3]=50.

2. Step 2: Set last element to 0

   arr[4] is set to 0 explicitly.

3. Final Answer:

   20 30 40 50 0 -> Option A

4. Quick Check:

   Shift left + last zero = 20 30 40 50 0 [OK]

Hint: After shift, last element set to zero to fill gap [OK]

Common Mistakes:

• Forgetting to set last element to zero
• Printing original array without shift
• Confusing shift direction

4. The following code attempts to delete the first element of an array but causes an error. What is the error?

int[] arr = {1, 2, 3, 4};
for (int i = 0; i <= arr.length - 1; i++) {
    arr[i] = arr[i + 1];
}

medium

A. Logical error: elements shift right instead of left

B. ArrayIndexOutOfBoundsException at i = 3

C. Syntax error due to missing semicolon

D. No error, code runs fine

Solution

1. Step 1: Analyze loop range

   The loop runs i from 0 to arr.length - 1 (i.e., 0 to 3).

2. Step 2: Identify out-of-bounds access

   At i=3, arr[i+1] = arr[4] is accessed, which is outside array bounds causing exception.

3. Final Answer:

   ArrayIndexOutOfBoundsException at i = 3 -> Option B

4. Quick Check:

   Accessing arr[4] in length 4 array causes exception [OK]

Hint: Loop till length-2 to avoid out-of-bounds [OK]

Common Mistakes:

• Using <= instead of < in loop condition
• Ignoring array length limits
• Assuming code runs without error

5. Given an array arr = {5, 10, 15, 20, 25}, write the output after deleting the first element twice using the standard shift-left method and setting the last element to zero each time.
What is the final state of the array?

hard

A. [5, 10, 15, 20, 25]

B. [10, 15, 20, 25, 0]

C. [0, 0, 15, 20, 25]

D. [15, 20, 25, 0, 0]

Solution

1. Step 1: First deletion

   Shift left: arr becomes [10, 15, 20, 25, 0]

2. Step 2: Second deletion

   Shift left again: arr becomes [15, 20, 25, 0, 0]

3. Final Answer:

   [15, 20, 25, 0, 0] -> Option D

4. Quick Check:

   Two shifts left + zeros at end = [15, 20, 25, 0, 0] [OK]

Hint: Each deletion shifts left and adds zero at end [OK]

Common Mistakes:

• Deleting only once instead of twice
• Not setting last element to zero after shift
• Confusing order of elements after shifts