Apply Operations to an Array — Editorial

Opening the reading…

Intuitionthe operation phase and the zero-shifting phase have different jobs

The first part of the problem is a left-to-right simulation. At index i, you must compare the current value with the value immediately to its right. If they match, the left value changes and the right value becomes zero. That new zero is part of the array state seen by the next operation, so the scan must use the modified array rather than the original values.

After every adjacent operation has happened, no more merging is allowed. The remaining task is stable compaction: read the array from left to right, copy each non-zero value into the next available position, and leave all positions after that filled with zero. Because values are copied in their original order, the non-zero order is preserved.

Approach

Store n, the array length, so both passes use the same fixed boundary and the last comparison stops at index n - 2.

Scan i from 0 to n - 2 and compare nums[i] with nums[i + 1]. The operation is sequential, so each comparison must see changes made by earlier comparisons.

When the adjacent values are equal, double nums[i] and set nums[i + 1] to zero. The zero prevents the newly doubled value from being merged again with the next position during this pass.

Create a result array of n zeros. Starting with zeros means every position not reached by a non-zero value already has its required final value.

Scan nums from left to right and maintain idx as the next result position. Copy each non-zero x into result[idx] and increment idx, because skipping zeros is exactly the required shift and this order keeps non-zero values stable.

Return result after the scan. Every original slot contributes either one copied non-zero value or one zero in the untouched suffix, so the returned length remains n.

Complexitytwo linear passes and output-sized storage

MEASURE	BOUND	WHY
Time	O(n)	The merge pass performs one comparison per adjacent pair, and the compaction pass reads each element once. The passes are separate but each touches at most n positions, so their total work is still linear.
Space	O(1) extra	The result array uses O(n) space, but it is the required returned output and is excluded. Apart from that output, the algorithm stores only n, i, idx, and x; the bound does not worsen for any input shape.

Here n denotes nums.length. The returned array is required output storage and is excluded from the extra-space bound.

Annotated solutionC++ · two passes · simulation followed by stable compaction

CPPApply all adjacent operations in order, then copy non-zero values into a zero-filled result.

#include <vector>
using namespace std;

class Solution {
public:
    vector<int> applyOperations(vector<int>& nums) {
        int n = nums.size();

        for (int i = 0; i < n - 1; ++i) {
            if (nums[i] == nums[i + 1]) {
                nums[i] *= 2;
                nums[i + 1] = 0;
            }
        }

        vector<int> result(n, 0);
        int idx = 0;
        for (int x : nums) {
            if (x != 0) {
                result[idx++] = x;
            }
        }

        return result;
    }
};

The boundary n - 1 is essential because nums[i + 1] must exist. The second pass does not try to move each zero individually; it only records where the next useful value belongs. Since result starts entirely at zero, the part after idx needs no separate shifting loop.

The in-place alternativean allocation-saving arrangement that reuses nums

You can avoid the separate result array by compacting the modified nums itself. This is a genuine space optimisation: the required output remains the same, but the algorithm uses no output-sized auxiliary vector. It also makes the input array hold the final answer, so use this version only when mutating nums is acceptable.

CPPReuse nums as the destination: write non-zero values forward, then fill the remaining suffix with zeros.

#include <vector>
using namespace std;

class Solution {
public:
    vector<int> applyOperations(vector<int>& nums) {
        int n = nums.size();

        for (int i = 0; i < n - 1; ++i) {
            if (nums[i] == nums[i + 1]) {
                nums[i] *= 2;
                nums[i + 1] = 0;
            }
        }

        int write = 0;
        for (int read = 0; read < n; ++read) {
            if (nums[read] != 0) {
                nums[write++] = nums[read];
            }
        }

        while (write < n) {
            nums[write++] = 0;
        }

        return nums;
    }
};

The read pointer always moves forward, while write never moves ahead of read because each copied value occupies the earliest unused position. That makes the compaction stable. The final loop restores zeros in every remaining slot; without it, old non-zero values could remain at the end after being overwritten earlier.