Duplicate Zeros

Duplicate Zeros - Problem

Given a fixed-length integer array arr, duplicate each occurrence of zero, shifting the remaining elements to the right.

Note: Elements beyond the length of the original array are not written. Do the above modifications to the input array in place and do not return anything.

Input & Output

Example 1 — Basic Duplication

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

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

💡 Note: Each zero is duplicated, shifting remaining elements right. Elements 5,0 are dropped as they exceed array length.

Example 2 — No Zeros

$ Input: arr = [1,2,3]

› Output: [1,2,3]

💡 Note: No zeros to duplicate, array remains unchanged.

Example 3 — All Zeros

$ Input: arr = [0,0,0]

› Output: [0,0,0]

💡 Note: First zero is duplicated, second zero pushes remaining elements out of bounds.

Constraints

1 ≤ arr.length ≤ 10⁴
0 ≤ arr[i] ≤ 9

Visualization

Tap to expand

Asked in

🍎 Apple 15 Ⓜ️ Microsoft 12

The key insight is to work backwards to avoid overwriting unprocessed elements. Best approach is the two-pass method: first count duplicable zeros, then place elements from right to left. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force - Extra Array

⏱️ Time: O(n) Space: O(n)

Create an auxiliary array and iterate through the original array, copying each element to the new array. When we encounter a zero, copy it twice. Finally, copy the result back to the original array.

Two-Pass Approach

⏱️ Time: O(n) Space: O(1)

Use two passes: first pass counts how many zeros need duplication, second pass works backwards placing elements in their final positions to avoid overwriting unprocessed elements.

Brute Force - Extra Array — Algorithm Steps

Create auxiliary array of same size
Iterate through original array copying elements
When zero found, add it twice to auxiliary array
Copy auxiliary array back to original

Visualization

Tap to expand

Step-by-Step Walkthrough

Original Array

Start with input array

Copy with Duplication

Create temp array, duplicate zeros

Copy Back

Copy result back to original array

Code -

solution.c — C

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

typedef struct {
    int x, y;
} Point;

long long crossProduct(Point o, Point a, Point b) {
    return (long long)(a.x - o.x) * (b.y - o.y) - (long long)(a.y - o.y) * (b.x - o.x);
}

bool isInsideOrOn(Point point, Point* hull, int hullSize) {
    for (int i = 0; i < hullSize; i++) {
        int j = (i + 1) % hullSize;
        if (crossProduct(hull[i], hull[j], point) < 0) {
            return false;
        }
    }
    return true;
}

bool isConvex(Point* points, int n) {
    if (n < 3) return true;
    
    int sign = 0;
    for (int i = 0; i < n; i++) {
        long long cp = crossProduct(points[i], points[(i+1)%n], points[(i+2)%n]);
        if (cp != 0) {
            int currentSign = (cp > 0) ? 1 : -1;
            if (sign == 0) {
                sign = currentSign;
            } else if (sign != currentSign) {
                return false;
            }
        }
    }
    return true;
}

bool isValidHull(Point* trees, int n, Point* hull, int hullSize, int* selected) {
    bool inHull[n];
    for (int i = 0; i < n; i++) inHull[i] = false;
    for (int i = 0; i < hullSize; i++) inHull[selected[i]] = true;
    
    for (int i = 0; i < n; i++) {
        if (!inHull[i]) {
            if (!isInsideOrOn(trees[i], hull, hullSize)) {
                return false;
            }
        }
    }
    
    return isConvex(hull, hullSize);
}

void generateCombinations(Point* trees, int n, int size, int start, int* current, int depth, Point** result, int* resultSize) {
    if (*resultSize > 0) return; // Found solution
    
    if (depth == size) {
        Point* hull = malloc(size * sizeof(Point));
        for (int i = 0; i < size; i++) {
            hull[i] = trees[current[i]];
        }
        
        if (isValidHull(trees, n, hull, size, current)) {
            *result = hull;
            *resultSize = size;
            return;
        }
        
        free(hull);
        return;
    }
    
    for (int i = start; i < n; i++) {
        current[depth] = i;
        generateCombinations(trees, n, size, i + 1, current, depth + 1, result, resultSize);
        if (*resultSize > 0) return;
    }
}

int** outerTrees(int** treesInput, int treesSize, int* treesColSize, int* returnSize, int** returnColumnSizes) {
    if (treesSize <= 1) {
        *returnSize = treesSize;
        *returnColumnSizes = malloc(treesSize * sizeof(int));
        int** result = malloc(treesSize * sizeof(int*));
        
        for (int i = 0; i < treesSize; i++) {
            (*returnColumnSizes)[i] = 2;
            result[i] = malloc(2 * sizeof(int));
            result[i][0] = treesInput[i][0];
            result[i][1] = treesInput[i][1];
        }
        return result;
    }
    
    Point* trees = malloc(treesSize * sizeof(Point));
    for (int i = 0; i < treesSize; i++) {
        trees[i].x = treesInput[i][0];
        trees[i].y = treesInput[i][1];
    }
    
    Point* hullResult = NULL;
    int hullSize = 0;
    
    // Try different hull sizes
    for (int size = 3; size <= treesSize && hullSize == 0; size++) {
        int* current = malloc(size * sizeof(int));
        generateCombinations(trees, treesSize, size, 0, current, 0, &hullResult, &hullSize);
        free(current);
    }
    
    if (hullSize == 0) {
        hullResult = trees;
        hullSize = treesSize;
    }
    
    *returnSize = hullSize;
    *returnColumnSizes = malloc(hullSize * sizeof(int));
    int** result = malloc(hullSize * sizeof(int*));
    
    for (int i = 0; i < hullSize; i++) {
        (*returnColumnSizes)[i] = 2;
        result[i] = malloc(2 * sizeof(int));
        result[i][0] = hullResult[i].x;
        result[i][1] = hullResult[i].y;
    }
    
    if (hullResult != trees) {
        free(hullResult);
    }
    free(trees);
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse input like [[1,1],[2,2],...]
    int treesSize = 0;
    int trees[3000][2];
    
    char* p = line + 1; // skip first [
    while (*p && *p != ']') {
        if (*p == '[') {
            p++;
            trees[treesSize][0] = atoi(p);
            while (*p && *p != ',') p++;
            if (*p == ',') p++;
            trees[treesSize][1] = atoi(p);
            while (*p && *p != ']') p++;
            if (*p == ']') p++;
            treesSize++;
        } else {
            p++;
        }
    }
    
    int* treePtrs[treesSize];
    for (int i = 0; i < treesSize; i++) treePtrs[i] = trees[i];
    
    int returnSize;
    int* returnColumnSizes;
    int** result = outerTrees(treePtrs, treesSize, NULL, &returnSize, &returnColumnSizes);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("[%d,%d]", result[i][0], result[i][1]);
        free(result[i]);
    }
    printf("]\n");
    
    free(result);
    free(returnColumnSizes);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array to copy elements

✓ Linear Growth

Space Complexity

O(n)

Auxiliary array of size n for temporary storage

⚡ Linearithmic Space

32.0K Views

Medium Frequency

~15 min Avg. Time

892 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

Brute Force - Extra Array — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler