Duplicate Zeros - Practice Coding Problems

Duplicate Zeros - Problem

Transform an array by duplicating zeros!

You're given a fixed-length integer array arr. Your task is to duplicate each occurrence of zero, shifting all remaining elements to the right. Here's the catch: the array size stays the same, so elements that get pushed beyond the original length are discarded.

Important: You must modify the input array in-place without returning anything.

Example: [1,0,2,3,0,4,5,0] becomes [1,0,0,2,3,0,0,4]
Notice how the original zeros at indices 1, 4, and 7 each get duplicated, pushing subsequent elements right until they fall off the end.

Input & Output

example_1.py — Basic Case

$ Input: [1,0,2,3,0,4,5,0]

› Output: [1,0,0,2,3,0,0,4]

💡 Note: The zeros at indices 1, 4, and 7 are duplicated. The first zero creates [1,0,0,2,3,0,4,5], the second zero creates [1,0,0,2,3,0,0,4,5], and since we exceed the array length, the 5 is dropped. The final zero would create another duplicate but it falls outside the array bounds.

example_2.py — Edge Case with Consecutive Zeros

$ Input: [1,0,0,1]

› Output: [1,0,0,0]

💡 Note: The first zero at index 1 gets duplicated, shifting everything right: [1,0,0,0,1]. The second original zero would also get duplicated, but there's no space left in the array, so the final result is [1,0,0,0] with the trailing elements dropped.

example_3.py — No Zeros

$ Input: [1,2,3,4]

› Output: [1,2,3,4]

💡 Note: Since there are no zeros in the array, no duplication occurs and the array remains unchanged.

Constraints

1 ≤ arr.length ≤ 10⁴
0 ≤ arr[i] ≤ 9
You must modify the array in-place
Do not return anything from your function

Visualization

Tap to expand

Understanding the Visualization

Survey the Belt

First, count how many zeros exist to predict the final layout

Work Backwards

Start from the end and work backwards to avoid disturbing items you haven't processed yet

Duplicate Zeros

When you encounter a zero, place two zeros in the final positions

Handle Overflow

Items that would exceed the belt length naturally fall off

Key Takeaway

🎯 Key Insight: Working backwards with pre-calculated positions ensures optimal O(n) performance while safely handling in-place modifications without data corruption.

Asked in

A Apple 35 ⊞ Microsoft 28 G Google 22 a Amazon 18

The optimal solution uses a two-pointer technique working backwards after calculating the logical array length. This avoids the O(n²) complexity of naive shifting by ensuring each element is moved exactly once. The key insight is that working backwards prevents overwriting unprocessed data while naturally handling array bounds.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Optimal)	O(n)	O(1)	Calculate final length first, then use two pointers working backwards
Brute Force (Shift for Each Zero)	O(n²)	O(1)	For each zero found, shift all elements to the right and insert duplicate

Two Pointers (Optimal) — Algorithm Steps

First pass: Count zeros and calculate the new logical length
Initialize two pointers: read pointer at original end, write pointer at logical end
Work backwards from right to left
If current element is zero, write two zeros (if space allows)
If current element is non-zero, write it once
Continue until read pointer reaches the beginning

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Zeros

First pass counts 3 zeros, so logical length becomes 11

Setup Pointers

Read pointer at index 7, write pointer at logical index 10

Work Backwards

Copy elements from right to left, duplicating zeros

Handle Overflow

Elements beyond array bounds are naturally discarded

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void duplicateZeros(int* arr, int arrSize) {
    // First pass: count zeros to find the new length
    int zeros = 0;
    for (int i = 0; i < arrSize; i++) {
        if (arr[i] == 0) zeros++;
    }
    
    // Calculate the last position of the new array
    int i = arrSize - 1;
    int j = arrSize + zeros - 1;
    
    // Second pass: fill the array backwards
    while (i >= 0 && j >= 0) {
        if (arr[i] != 0) {
            if (j < arrSize) {
                arr[j] = arr[i];
            }
            j--;
        } else {
            // Handle zero: place two zeros
            if (j < arrSize) {
                arr[j] = 0;
            }
            j--;
            if (j < arrSize) {
                arr[j] = 0;
            }
            j--;
        }
        i--;
    }
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    int arr[100];
    int size = 0;
    char* token = strtok(input + 1, ",]");
    while (token != NULL) {
        arr[size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    duplicateZeros(arr, size);
    
    printf("[");
    for (int i = 0; i < size; i++) {
        printf("%d", arr[i]);
        if (i < size - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two passes through the array: O(n) + O(n) = O(n)

✓ Linear Growth

Space Complexity

O(1)

Only using a few pointer variables, modifying array in-place

✓ Linear Space

38.5K Views

Medium Frequency

~15 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Two Pointers (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler