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

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output after deleting the last element from the array?

Consider the following Java code that deletes the last element from an array by reducing its size logically. What will be printed?

DSA Java

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

A 10 20 30 40 50

B 10 20 30 40

C 20 30 40 50

D 10 20 30 50

💡 Hint

Think about how reducing the size variable affects the loop.

The size variable is reduced by one, so the loop prints all elements except the last one (50).

❓ Predict Output

intermediate

What happens if we try to access the deleted element after reducing size?

Given the code below, what will be the output or error?

DSA Java

int[] arr = {5, 15, 25, 35};
int size = arr.length;
size--;
System.out.println(arr[size]);

A 35

B 15

C ArrayIndexOutOfBoundsException

D 25

💡 Hint

Remember size was decremented before accessing arr[size].

After decrement, size is 3, so arr[3] is accessed which is 35.

🔧 Debug

advanced

Why does this code print the last element even after deletion?

Analyze the code below. It tries to delete the last element by reducing size, but the output still includes the last element. Why?

DSA Java

int[] arr = {1, 2, 3, 4, 5};
int size = arr.length;
size = size - 1;
for (int i = 0; i <= size; i++) {
    System.out.print(arr[i] + " ");
}

A Because the print statement is inside the loop.

B Because size was not decremented properly.

C Because arrays in Java cannot be resized.

D Because the loop condition uses <=, it includes the last element index.

💡 Hint

Check the loop condition carefully.

The loop runs from i=0 to i=size inclusive, so it prints elements at indices 0 to size, including the last element.

🧠 Conceptual

advanced

What is the main limitation of deleting the last element in a fixed-size array?

Why can't we physically remove the last element from a fixed-size array in Java?

A Because arrays have fixed length and cannot be resized after creation.

B Because Java does not allow modifying array elements.

C Because deleting elements requires special syntax.

D Because the last element is always protected.

💡 Hint

Think about how arrays are stored in memory.

Arrays in Java have a fixed length set at creation time; you cannot change their size dynamically.

🚀 Application

expert

How to implement logical deletion of last element in an array?

You want to delete the last element from an array logically without creating a new array. Which approach is correct?

A Set the last element to zero and keep size unchanged.

B Shift all elements left by one and reduce size.

C Maintain a size variable and decrement it when deleting; use size to control access.

D Create a new array with one less element and copy all elements except last.

💡 Hint

Logical deletion means ignoring the element without changing the array size.

By keeping a size variable and decrementing it, you can ignore the last element without reallocating the array.

Practice

1. What happens when you delete an element from the end of a fixed-size array in Java?

easy

A. The last element is removed and the array size decreases by one

B. The last element is set to zero or null but the array size stays the same

C. All elements shift left by one position

D. The array is completely cleared

Solution

1. Step 1: Understand fixed-size array behavior

   Java arrays have a fixed size once created, so their length cannot change.

2. Step 2: Effect of deleting at end

   Deleting means logically ignoring the last element or setting it to default (0 or null), but the array length remains unchanged.

3. Final Answer:

   The last element is set to zero or null but the array size stays the same -> Option B

4. Quick Check:

   Fixed-size array length unchanged on deletion [OK]

Hint: Fixed arrays keep size; deletion just clears last element [OK]

Common Mistakes:

• Thinking array size shrinks automatically
• Assuming elements shift after deletion
• Believing array clears fully on one deletion

2. Which of the following is the correct syntax to delete the last element from an array named arr in Java by reducing its logical size stored in size?

easy

A. arr[size--] = 0;

B. arr[size] = 0; size--;

C. size--; arr[size] = 0;

D. arr[size] = null; size++;

Solution

1. Step 1: Understand logical deletion

   To delete last element, first reduce size by one, then clear that element.

2. Step 2: Check syntax correctness

   size--; arr[size] = 0; reduces size first (size--) then sets arr[size] to 0, correctly deleting last element.

3. Final Answer:

   size--; arr[size] = 0; -> Option C

4. Quick Check:

   Decrease size before clearing element [OK]

Hint: Decrease size first, then clear element [OK]

Common Mistakes:

• Clearing element before decreasing size
• Using post-decrement incorrectly
• Increasing size instead of decreasing

3. What will be the output of the following Java code?

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

medium

A. 10 20 30 0 0

B. 10 20 30 40 0

C. 10 20 30 40 50

D. 10 20 30 40

Solution

1. Step 1: Understand size decrement and element clearing

   Size is reduced from 5 to 4, then arr[4] is set to 0, removing last element logically.

2. Step 2: Loop prints elements from index 0 to 3

   Loop runs i=0 to 3, printing arr[0]=10, arr[1]=20, arr[2]=30, arr[3]=40.

3. Final Answer:

   10 20 30 40 -> Option D

4. Quick Check:

   Last element removed, loop prints first 4 elements [OK]

Hint: Loop runs till size, last element skipped after decrement [OK]

Common Mistakes:

• Printing all 5 elements ignoring size
• Not updating last element to zero
• Confusing array index with size

4. Identify the error in this Java code snippet that tries to delete the last element from an array:

int[] arr = {1, 2, 3, 4};
int size = 4;
arr[size] = 0;
size--;

medium

A. Array index out of bounds error at arr[size] = 0;

B. Size variable is not decremented

C. Array elements are not shifted left

D. No error, code works fine

Solution

1. Step 1: Check array indexing

   Array indices go from 0 to size-1, so arr[size] is out of bounds.

2. Step 2: Identify correct order

   Must decrement size first, then access arr[size] to avoid error.

3. Final Answer:

   Array index out of bounds error at arr[size] = 0; -> Option A

4. Quick Check:

   Accessing arr[size] causes error [OK]

Hint: Decrement size before accessing arr[size] [OK]

Common Mistakes:

• Accessing arr[size] directly
• Not decrementing size before deletion
• Ignoring array index limits

5. You have an array int[] arr = {5, 10, 15, 20, 25} and a variable size = 5. You want to logically delete the last two elements without modifying the values in the array and print the remaining elements. Which code snippet correctly does this?

hard

A. size -= 2;
for(int i = 0; i < size; i++) System.out.print(arr[i] + " ");

B. arr[size-1] = 0; arr[size-2] = 0; size -= 2;
for(int i = 0; i < size; i++) System.out.print(arr[i] + " ");

C. size -= 2;
arr[size] = 0; arr[size+1] = 0;
for(int i = 0; i < size; i++) System.out.print(arr[i] + " ");

D. for(int i = 0; i < size-2; i++) System.out.print(arr[i] + " ");

Solution

1. Step 1: Reduce logical size by 2

   Decreasing size by 2 means last two elements are ignored logically.

2. Step 2: Print elements up to new size

   Loop from 0 to size-1 prints remaining elements correctly.

3. Final Answer:

   size -= 2; for(int i = 0; i < size; i++) System.out.print(arr[i] + " "); -> Option A

4. Quick Check:

   Logical size controls printed elements [OK]

Hint: Reduce size, then print up to size [OK]

Common Mistakes:

• Setting elements to zero before reducing size
• Printing without adjusting size
• Accessing invalid indices after deletion