Apply Operations to an Array - Practice Coding Problems

Apply Operations to an Array - Problem

You're given an array of non-negative integers and need to perform a sequential transformation process followed by a cleanup operation.

The Process:

Apply Operations: Go through the array from left to right. For each element at position i, if it equals the next element at position i+1, then:
- Double the current element: nums[i] *= 2
- Set the next element to zero: nums[i+1] = 0
Move Zeros: After all operations, shift all zeros to the end of the array while maintaining the relative order of non-zero elements.

Example: [1,0,2,2,1,0,0,1] becomes [1,0,4,1,1,0,0,0] after operations, then [1,4,1,1,0,0,0,0] after moving zeros.

Remember: Operations are applied sequentially, not simultaneously!

Input & Output

example_1.py — Basic Case

$ Input: nums = [1,0,2,2,1,0,0,1]

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

💡 Note: Apply operations: [1,0,2,2,1,0,0,1] → [1,0,4,0,1,0,0,1] (2==2 becomes 4,0). Move zeros: [1,4,1,1,0,0,0,0]

example_2.py — Multiple Operations

$ Input: nums = [2,2,4,4,8,8]

› Output: [4,8,16,0,0,0]

💡 Note: Operations: [2,2,4,4,8,8] → [4,0,8,0,16,0]. Move zeros to end: [4,8,16,0,0,0]

example_3.py — No Operations

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

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

💡 Note: No adjacent elements are equal, so no operations applied. No zeros to move, array stays the same.

Visualization

Tap to expand

Understanding the Visualization

Merge Phase

Identical adjacent candies get combined into double-sized candies, leaving empty spaces

Collection Phase

Use two workers (pointers) to efficiently collect all real candies and move empty spaces to the end

Key Takeaway

🎯 Key Insight: Two-phase processing is optimal - we must complete all merge operations before rearranging, and two pointers make the rearrangement efficient in O(n) time.

Time & Space Complexity

Time Complexity

⏱️

O(n)

O(n) for applying operations + O(n) for moving zeros with two pointers

✓ Linear Growth

Space Complexity

O(1)

Only using two pointer variables and constant extra space

✓ Linear Space

Constraints

2 ≤ nums.length ≤ 2000
0 ≤ nums[i] ≤ 1000
Operations are applied sequentially, not simultaneously
Must maintain relative order of non-zero elements after moving zeros

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 f Meta 6

The optimal solution uses a two-phase approach: first apply operations sequentially (O(n)), then use two pointers to efficiently move zeros to the end (O(n)). Total time complexity is O(n) with O(1) extra space.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Optimal)	O(n)	O(1)	Apply operations sequentially, then use two pointers to efficiently move non-zeros
Brute Force (Multiple Passes)	O(n²)	O(1)	Apply operations sequentially, then repeatedly shift zeros to the end

Two Pointers (Optimal) — Algorithm Steps

Apply operations sequentially from left to right
Use write pointer to track where to place next non-zero element
Use read pointer to scan through all elements
Copy non-zero elements to write position and increment write pointer
Fill remaining positions with zeros

Visualization

Tap to expand

Step-by-Step Walkthrough

Apply Operations

Process array sequentially for merge operations

Two Pointer Setup

Initialize read and write pointers

Collect Non-zeros

Copy non-zero elements to write position

Fill Zeros

Fill remaining positions with zeros

Code -

solution.c — C

int* applyOperations(int* nums, int numsSize, int* returnSize) {
    *returnSize = numsSize;
    
    // Step 1: Apply operations sequentially
    for (int i = 0; i < numsSize - 1; i++) {
        if (nums[i] == nums[i + 1]) {
            nums[i] *= 2;
            nums[i + 1] = 0;
        }
    }
    
    // Step 2: Move zeros to end using two pointers
    int writePos = 0;
    
    // Move all non-zero elements to the front
    for (int readPos = 0; readPos < numsSize; readPos++) {
        if (nums[readPos] != 0) {
            nums[writePos] = nums[readPos];
            writePos++;
        }
    }
    
    // Fill remaining positions with zeros
    while (writePos < numsSize) {
        nums[writePos] = 0;
        writePos++;
    }
    
    return nums;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

O(n) for applying operations + O(n) for moving zeros with two pointers

✓ Linear Growth

Space Complexity

O(1)

Only using two pointer variables and constant extra space

✓ Linear Space

Constraints

2 ≤ nums.length ≤ 2000
0 ≤ nums[i] ≤ 1000
Operations are applied sequentially, not simultaneously
Must maintain relative order of non-zero elements after moving zeros

24.7K Views

Medium Frequency

~15 min Avg. Time

842 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Two Pointers (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler