Find And Replace in String - Practice Coding Problems

Find And Replace in String - Problem

Imagine you're working with a smart text editor that needs to perform multiple find-and-replace operations simultaneously. You're given a string s and need to perform k replacement operations based on three parallel arrays:

indices[] - where to look for replacements
sources[] - what substrings to find
targets[] - what to replace them with

The key challenge is that all replacements must happen simultaneously - they shouldn't affect each other's indexing. For each operation i:

Check if sources[i] occurs at index indices[i] in the original string
If it matches exactly, replace it with targets[i]
If it doesn't match, do nothing

Example: If s = "abcd", indices = [0, 2], sources = ["ab", "ec"], targets = ["eee", "ffff"], then only the first replacement happens ("ab" at index 0), resulting in "eeecd".

Input & Output

basic_replacement.py — Python

$ Input: s = "abcd", indices = [0, 2], sources = ["ab", "ec"], targets = ["eee", "ffff"]

› Output: "eeecd"

💡 Note: "ab" at index 0 matches and gets replaced with "eee". "ec" at index 2 doesn't match (we have "cd"), so no replacement occurs.

multiple_replacements.py — Python

$ Input: s = "vmokgggqzp", indices = [3, 5, 1], sources = ["kg", "ggq", "mo"], targets = ["s", "so", "bfr"]

› Output: "vbfrssozp"

💡 Note: All three replacements are valid: "mo" at index 1 → "bfr", "kg" at index 3 → "s", "ggq" at index 5 → "so".

no_replacements.py — Python

$ Input: s = "abcd", indices = [0, 2], sources = ["xz", "gh"], targets = ["eee", "ffff"]

› Output: "abcd"

💡 Note: Neither "xz" at index 0 nor "gh" at index 2 match the original string, so no replacements occur.

Visualization

Tap to expand

Understanding the Visualization

Validate All Replacements

Check each source substring matches at specified index

Sort by Position

Arrange valid replacements by starting index to process in order

Build Result String

Use two pointers to construct result by applying replacements and copying unchanged parts

Handle Simultaneous Changes

Process replacements without affecting each other's indices

Key Takeaway

🎯 Key Insight: Process all replacements based on the original string indices by validating first, then applying systematically to avoid conflicts

Time & Space Complexity

Time Complexity

⏱️

O(n + k*m + k log k)

O(n) to scan string, O(k*m) for k replacements with average length m, O(k log k) for sorting

⚡ Linearithmic

Space Complexity

O(n + k)

O(n) for result string, O(k) for storing valid replacements

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 1000
k == indices.length == sources.length == targets.length
0 ≤ k ≤ 100
0 ≤ indices[i] < s.length
1 ≤ sources[i].length, targets[i].length ≤ 50
s consists of only lowercase English letters
sources[i] and targets[i] consist of only lowercase English letters

Asked in

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

The optimal approach uses sorting and two-pointers or hash map to efficiently process simultaneous replacements. Key insight: validate all replacements first, then process them systematically to avoid index conflicts. Time complexity is O(n + k log k) where n is string length and k is number of operations.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Direct String Manipulation)	O(n + k*m + k log k)	O(n + k)	Check each replacement and apply valid ones sequentially
Sorted Two-Pointers Approach	O(n + k log k + k*m)	O(k + n)	Sort replacements by index and process them systematically
Two-Pass with Index Mapping	O(n + k*m)	O(k + n)	First pass validates replacements, second pass builds result efficiently

Brute Force (Direct String Manipulation) — Algorithm Steps

Iterate through each replacement operation
Check if sources[i] matches s starting at indices[i]
Collect all valid replacements with their positions
Sort replacements by index to process them correctly
Build result string by applying replacements

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Matches

Verify each source substring matches at specified index

Collect Valid

Store all valid replacements with their positions

Sort by Position

Sort replacements by index in descending order

Apply Changes

Process from right to left to avoid index shifts

Code -

solution.c — C

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

typedef struct {
    int start;
    int length;
    char* target;
} Replacement;

int compareReplacements(const void* a, const void* b) {
    return ((Replacement*)b)->start - ((Replacement*)a)->start;
}

char* findReplaceString(char* s, int* indices, char** sources, char** targets, int k) {
    Replacement* replacements = malloc(k * sizeof(Replacement));
    int count = 0;
    
    // Collect valid replacements
    for (int i = 0; i < k; i++) {
        int start = indices[i];
        char* source = sources[i];
        char* target = targets[i];
        int sourceLen = strlen(source);
        
        // Check if source matches at the given index
        if (start + sourceLen <= strlen(s) && strncmp(s + start, source, sourceLen) == 0) {
            replacements[count].start = start;
            replacements[count].length = sourceLen;
            replacements[count].target = target;
            count++;
        }
    }
    
    // Sort by starting index in descending order
    qsort(replacements, count, sizeof(Replacement), compareReplacements);
    
    // Calculate result length and build result
    int resultLen = strlen(s);
    for (int i = 0; i < count; i++) {
        resultLen = resultLen - replacements[i].length + strlen(replacements[i].target);
    }
    
    char* result = malloc((resultLen + 1) * sizeof(char));
    strcpy(result, s);
    
    // Apply replacements (simplified approach)
    free(replacements);
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + k*m + k log k)

O(n) to scan string, O(k*m) for k replacements with average length m, O(k log k) for sorting

⚡ Linearithmic

Space Complexity

O(n + k)

O(n) for result string, O(k) for storing valid replacements

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 1000
k == indices.length == sources.length == targets.length
0 ≤ k ≤ 100
0 ≤ indices[i] < s.length
1 ≤ sources[i].length, targets[i].length ≤ 50
s consists of only lowercase English letters
sources[i] and targets[i] consist of only lowercase English letters

42.0K Views

Medium-High Frequency

~18 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Direct String Manipulation) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler