Replace Elements in an Array - Practice Coding Problems

Replace Elements in an Array - Problem

You are given a 0-indexed array nums that consists of n distinct positive integers. Apply m operations to this array, where in the i-th operation you replace the number operations[i][0] with operations[i][1].

It is guaranteed that in the i-th operation:

operations[i][0] exists in nums.
operations[i][1] does not exist in nums.

Return the array obtained after applying all the operations.

Input & Output

Example 1 — Basic Replacement

$ Input: nums = [1,2,6,7,8], operations = [[1,3],[6,4]]

› Output: [3,2,4,7,8]

💡 Note: First operation: replace 1 with 3, array becomes [3,2,6,7,8]. Second operation: replace 6 with 4, final array is [3,2,4,7,8].

Example 2 — Single Operation

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

› Output: [1,5,3]

💡 Note: Only one operation: replace 2 with 5, so nums[1] changes from 2 to 5.

Example 3 — No Change Elements

$ Input: nums = [10,20,30,40], operations = [[10,50],[30,60]]

› Output: [50,20,60,40]

💡 Note: Replace 10→50 and 30→60. Elements 20 and 40 remain unchanged as they're not in operations.

Constraints

1 ≤ nums.length ≤ 10³
1 ≤ nums[i] ≤ 10⁶
1 ≤ operations.length ≤ 10³
operations[i].length == 2
1 ≤ operations[i][0], operations[i][1] ≤ 10⁶
operations[i][0] exists in nums
operations[i][1] does not exist in nums
All values in nums are distinct

Visualization

Tap to expand

Understanding the Visualization

Input

nums = [1,2,6,7,8], operations = [[1,3],[6,4]]

Process

Apply each operation: replace target elements with new values

Output

Result array: [3,2,4,7,8]

Key Takeaway

🎯 Key Insight: Use hash map to precompute all replacements, then apply changes in single pass for optimal efficiency.

Asked in

a Amazon 25 G Google 18 M Microsoft 15

The key insight is to use a hash map to transform O(n) array searches into O(1) lookups. Build a replacement mapping from operations first, then apply all changes in a single pass. Hash map approach achieves optimal Time: O(n+m), Space: O(m).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Linear Search	O(n × m)	O(1)	For each operation, search entire array to find and replace elements
Hash Map Optimization	O(n + m)	O(m)	Build replacement mapping first, then apply all changes in single pass

Brute Force Linear Search — Algorithm Steps

Step 1: For each operation [old, new], scan entire nums array
Step 2: When nums[i] equals old value, replace with new value
Step 3: Continue until all operations are processed

Visualization

Tap to expand

Step-by-Step Walkthrough

Operation 1

Scan array to find and replace first target

Operation 2

Scan array again to find and replace second target

Result

All operations completed

Code -

solution.c — C

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

void solution(int* nums, int numsSize, int** operations, int operationsSize) {
    for (int i = 0; i < operationsSize; i++) {
        int oldVal = operations[i][0];
        int newVal = operations[i][1];
        for (int j = 0; j < numsSize; j++) {
            if (nums[j] == oldVal) {
                nums[j] = newVal;
            }
        }
    }
}

int main() {
    char line[10000];
    
    // Read nums array
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int nums[1000];
    int numsSize = 0;
    char* ptr = line + 1;
    while (*ptr && *ptr != ']') {
        if (*ptr == ',') ptr++;
        nums[numsSize++] = strtol(ptr, &ptr, 10);
    }
    
    // Read operations array
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int operations[100][2];
    int operationsSize = 0;
    ptr = line + 1;
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            operations[operationsSize][0] = strtol(ptr, &ptr, 10);
            if (*ptr == ',') ptr++;
            operations[operationsSize][1] = strtol(ptr, &ptr, 10);
            operationsSize++;
        }
        ptr++;
    }
    
    int* opsArray[100];
    for (int i = 0; i < operationsSize; i++) {
        opsArray[i] = operations[i];
    }
    
    solution(nums, numsSize, opsArray, operationsSize);
    
    printf("[");
    for (int i = 0; i < numsSize; i++) {
        printf("%d", nums[i]);
        if (i < numsSize - 1) printf(",");
    }
    printf("]\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

For each of m operations, we scan through n elements

✓ Linear Growth

Space Complexity

O(1)

Only using variables, no extra data structures

✓ Linear Space

32.4K Views

Medium Frequency

~15 min Avg. Time

890 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 Linear Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler