Replace Elements in an Array

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

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

✓ Brute Force Linear Search

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

Process each operation by scanning through the entire array to find all occurrences of the target element and replace them. This approach directly implements the problem requirements without optimization.

Hash Map Optimization

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

Create a hash map from the operations to build a complete replacement mapping, then iterate through the array once to apply all replacements. This reduces redundant array scans.

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>
#include <ctype.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;
                break; // Since all elements are distinct, we can break after finding the match
            }
        }
    }
}

int parseNums(char* line, int* nums) {
    int count = 0;
    char* ptr = line;
    while (*ptr) {
        if (isdigit(*ptr) || (*ptr == '-' && isdigit(*(ptr+1)))) {
            nums[count++] = strtol(ptr, &ptr, 10);
        } else {
            ptr++;
        }
    }
    return count;
}

int parseOperations(char* line, int operations[][2]) {
    int count = 0;
    char* ptr = line;
    
    // Skip to first '['
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr == '[') ptr++; // Skip outer '['
    
    while (*ptr) {
        // Skip whitespace and commas
        while (*ptr && (*ptr == ' ' || *ptr == ',' || *ptr == '\t')) ptr++;
        
        if (*ptr == '[') {
            ptr++; // Skip inner '['
            
            // Parse first number
            while (*ptr && !isdigit(*ptr) && *ptr != '-') ptr++;
            if (*ptr) {
                operations[count][0] = strtol(ptr, &ptr, 10);
            }
            
            // Skip to comma
            while (*ptr && *ptr != ',') ptr++;
            if (*ptr == ',') ptr++;
            
            // Parse second number
            while (*ptr && !isdigit(*ptr) && *ptr != '-') ptr++;
            if (*ptr) {
                operations[count][1] = strtol(ptr, &ptr, 10);
            }
            
            // Skip to closing bracket
            while (*ptr && *ptr != ']') ptr++;
            if (*ptr == ']') ptr++;
            
            count++;
        } else if (*ptr == ']') {
            break; // End of outer array
        } else {
            ptr++;
        }
    }
    return count;
}

int main() {
    char line[10000];
    
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int nums[1000];
    int numsSize = parseNums(line, nums);
    
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int operations[100][2];
    int operationsSize = parseOperations(line, operations);
    
    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