Cracking "Duplicate Zeros" with 0ms Runtime

Just hit that 0ms (100th percentile) milestone on LeetCode! Here is a quick breakdown of how to solve the Duplicate Zeros problem using a clean "Buffer" strategy.

The Challenge

Duplicate every 0 in a fixed-length array while shifting other elements to the right. Anything pushed beyond the original array size is discarded.

Example:

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

The Strategy: Speed Over Space

While the "ideal" interview answer is an in-place, two-pointer approach O(1) space, I used a Buffer Strategy O(n) space:
The Buffer: I created a temporary vector to store the result.
The Logic: Iterate through the array. If it's a 0, push two. If not, push one.
The Sync: Overwrite the original array.

The Code (C++)

class Solution {
public:
    void duplicateZeros(vector<int>& arr) {
        vector<int> res;
        for(int x : arr) {
            if(x == 0) {
                res.push_back(0); res.push_back(0);
            } else {
                res.push_back(x);
            }
        }

        // Overwrite in-place as requested (using our buffer)
        for(int i = 0; i < arr.size(); ++i) {
            arr[i] = res[i];
        }
    }
};

Performance vs. Requirements

My Runtime: 0 ms (Beats 100%)
The Constraint: "Do it in place."

Is it wrong? Technically, it violates the O(1) space constraint usually intended by "in-place."
Is it fast? Absolutely. Modern memory allocation and linear copying are so optimized that this approach often outperforms complex pointer logic on small-to-medium datasets.

Takeaway

In a real interview, I'd explain the O(1) space-optimal approach (iterating backward), but in a production environment, sometimes the most readable code is the best code.How do you feel about using extra space to gain performance? Let’s debate in the comments!