Replace Elements in an Array - Practice Coding Problems

Replace Elements in an Array - Problem

You are given a 0-indexed array nums consisting of n distinct positive integers. Your task is to perform a series of replacement operations that will transform this array step by step.

You need to apply m operations to this array, where each operation is defined by a pair [oldValue, newValue]. In the i-th operation, you must:

Find the element operations[i][0] in the array
Replace it with operations[i][1]

Important guarantees:

🎯 operations[i][0] always exists in the current array
🎯 operations[i][1] never exists in the current array before replacement

Return the final array after applying all operations in sequence.

Example: If nums = [1,2,4,6] and operations = [[1,3],[4,7],[6,1]]:
• Replace 1 → 3: [3,2,4,6]
• Replace 4 → 7: [3,2,7,6]
• Replace 6 → 1: [3,2,7,1]

Input & Output

example_1.py — Basic Replacement

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

› Output: [3,2,7,1]

💡 Note: Step by step: [1,2,4,6] → replace 1 with 3 → [3,2,4,6] → replace 4 with 7 → [3,2,7,6] → replace 6 with 1 → [3,2,7,1]

example_2.py — Chain Replacements

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

› Output: [2,1]

💡 Note: Operations create a cycle: [1,2] → [3,2] → [3,1] → [2,1]. Notice how values can be reused after being replaced.

example_3.py — Single Element

$ Input: nums = [5], operations = [[5,10]]

› Output: [10]

💡 Note: Edge case with single element: simply replace 5 with 10.

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Initial Setup

Start with books [1,2,4,6] on shelves 0,1,2,3. Create catalog: {1→shelf0, 2→shelf1, 4→shelf2, 6→shelf3}

First Replacement

Replace book 1 with book 3: Look up book 1 in catalog (shelf 0), swap it with book 3, update catalog

Continue Efficiently

Each subsequent replacement uses the catalog for instant lookup instead of searching every shelf

Final Result

After all replacements: [3,2,7,1] with updated catalog maintaining accuracy

Key Takeaway

🎯 Key Insight: By maintaining a catalog (hash map) of book locations, we transform expensive shelf-by-shelf searches into instant lookups, making the library management system highly efficient for multiple book replacements!

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal solution uses a hash map to maintain value-to-index mapping, achieving O(n + m) time complexity. Instead of searching the array linearly for each operation (O(n × m)), we can find any element's index in O(1) time. The key insight is trading O(n) space for dramatically improved time performance when dealing with multiple operations.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Linear Search)	O(n × m)	O(1)	For each operation, linearly search the array to find the target element
Hash Map for Index Lookup (Optimal)	O(n + m)	O(n)	Use hash map to store value-to-index mapping for O(1) lookups

Brute Force (Linear Search) — Algorithm Steps

Iterate through each operation [oldValue, newValue]
For each operation, scan the array from start to end
When we find the oldValue, replace it with newValue
Continue to the next operation
Return the final modified array

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Operation

Begin with operation [1,3] - need to find and replace 1 with 3

Linear Search

Scan array from index 0 until we find the value 1

Replace Value

Replace found value with new value and move to next operation

Repeat Process

Repeat the linear search process for each remaining operation

Code -

solution.c — C

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

int* arrayChange(int* nums, int numsSize, int** operations, int operationsSize, int* returnSize) {
    /**
     * Replace elements using brute force linear search
     */
    *returnSize = numsSize;
    
    for (int op = 0; op < operationsSize; op++) {
        int oldVal = operations[op][0];
        int newVal = operations[op][1];
        
        // Linear search for the old value
        for (int i = 0; i < numsSize; i++) {
            if (nums[i] == oldVal) {
                nums[i] = newVal;
                break; // Found and replaced, move to next operation
            }
        }
    }
    
    return nums;
}

int main() {
    // Simple demo with hardcoded values
    int nums[] = {1, 2, 4, 6};
    int op1[] = {1, 3};
    int op2[] = {4, 7};
    int op3[] = {6, 1};
    int* operations[] = {op1, op2, op3};
    
    int returnSize;
    int* result = arrayChange(nums, 4, operations, 3, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

For each of the m operations, we may need to scan the entire array of size n to find the target element

✓ Linear Growth

Space Complexity

O(1)

Only using a constant amount of extra space for loop variables

✓ Linear Space

48.0K Views

Medium Frequency

~15 min Avg. Time

1.4K 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