Replace All Elements with Zero in an Array

Problem Statement

Given an array of elements, the task is to replace every element of the array with zero.

This means:

• The size of the array remains the same
• Only the values stored at each index are modified
• After the operation, every index contains 0

Why This Problem Is Important

Although simple, this problem helps in understanding:

• In-place modification of arrays
• Array traversal and index-based updates
• Difference between changing values vs changing structure
• Memory efficiency (no new array required)

This operation is frequently used in:

• Resetting buffers
• Initializing data structures
• Clearing previous results
• Simulation and test-case preparation

Input and Output Format

Input

Array: [5, 10, -3, 8, 12]

Output

Array after replacement: [0, 0, 0, 0, 0]

Key Concept

An array stores values at fixed indices.
By traversing the array and assigning 0 at each index, we overwrite existing values without changing the array size.

Step-by-Step Algorithm

1. Traverse the array from index 0 to n-1
2. For each index i:
   • Assign array[i] = 0
3. Print the updated array

Pseudocode

for i = 0 to n-1:
    array[i] = 0

Dry Run Example

Original Array: [5, 10, -3, 8, 12]

Index 0 → replace 5 with 0
Index 1 → replace 10 with 0
Index 2 → replace -3 with 0
Index 3 → replace 8 with 0
Index 4 → replace 12 with 0

Final Array: [0, 0, 0, 0, 0]

Time and Space Complexity

The replacement is done in-place, so no extra memory is used.

Language-wise Implementation

C Implementation

#include 

int main() {
    int arr[] = {5, 10, -3, 8, 12};
    int n = sizeof(arr) / sizeof(arr[0]);

    for(int i = 0; i < n; i++) {
        arr[i] = 0;
    }

    printf("Array after replacement: ");
    for(int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }

    return 0;
}

Output

Array after replacement: 0 0 0 0 0

C++ Implementation

#include 
using namespace std;

int main() {
    int arr[] = {5, 10, -3, 8, 12};
    int n = sizeof(arr) / sizeof(arr[0]);

    for(int i = 0; i < n; i++) {
        arr[i] = 0;
    }

    cout << "Array after replacement: ";
    for(int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }

    return 0;
}

Output

Array after replacement: 0 0 0 0 0

Java Implementation

public class Main {
    public static void main(String[] args) {
        int[] arr = {5, 10, -3, 8, 12};

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

        System.out.print("Array after replacement: ");
        for(int num : arr) {
            System.out.print(num + " ");
        }
    }
}

Output

Array after replacement: 0 0 0 0 0

Python Implementation

arr = [5, 10, -3, 8, 12]

for i in range(len(arr)):
    arr[i] = 0

print("Array after replacement:", arr)

Output

Array after replacement: [0, 0, 0, 0, 0]

C# Implementation

using System;

class Program {
    static void Main() {
        int[] arr = {5, 10, -3, 8, 12};

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

        Console.Write("Array after replacement: ");
        foreach(int num in arr) {
            Console.Write(num + " ");
        }
    }
}

Output

Array after replacement: 0 0 0 0 0

JavaScript Implementation

let arr = [5, 10, -3, 8, 12];

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

console.log("Array after replacement:", arr);

Output

Array after replacement: [0, 0, 0, 0, 0]

Common Mistakes

• Creating a new array unnecessarily
• Forgetting to print the updated array
• Using incorrect loop bounds
• Assuming array size changes after replacement

Interview Variations

• Replace elements with a given value k
• Replace only even or odd elements with zero
• Reset array using built-in functions
• Replace elements conditionally

Detailed Summary

Replacing all elements of an array with zero is a fundamental in-place modification problem. It emphasizes how arrays store data at fixed indices and how those values can be overwritten without altering the array’s size or structure. By performing a single traversal and updating each index directly, the operation remains memory-efficient with constant space usage. This problem forms the basis for understanding array initialization, clearing data structures, and preparing arrays for reuse in real-world programming and algorithmic scenarios.

Next Problem in the Series

Sum of Elements at Even Indices