Apply Substitutions

Apply Substitutions - Problem

Array Hash Table String Depth-First Search Breadth-First Search Graph Topological Sort Medium

You are given a replacements mapping and a text string that may contain placeholders formatted as %var%, where each var corresponds to a key in the replacements mapping.

Each replacement value may itself contain one or more such placeholders. Each placeholder is replaced by the value associated with its corresponding replacement key.

Return the fully substituted text string which does not contain any placeholders.

Input & Output

Example 1 — Basic Substitution

$ Input: replacements = {"name": "John", "place": "NYC"}, text = "Hello %name%, welcome to %place%!"

› Output: "Hello John, welcome to NYC!"

💡 Note: Direct substitution: %name% becomes "John" and %place% becomes "NYC"

Example 2 — Nested Placeholders

$ Input: replacements = {"name": "Alice", "greeting": "Hi %name%!"}, text = "%greeting% How are you?"

› Output: "Hi Alice! How are you?"

💡 Note: First %greeting% becomes "Hi %name%!", then %name% becomes "Alice"

Example 3 — No Replacements Needed

$ Input: replacements = {"name": "Bob"}, text = "Hello world!"

› Output: "Hello world!"

💡 Note: Text contains no placeholders, so it remains unchanged

Constraints

1 ≤ replacements.length ≤ 100
1 ≤ text.length ≤ 1000
All replacement keys and values contain only alphanumeric characters
No circular dependencies in replacement values

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is recognizing this as a dependency resolution problem where replacement values can contain other placeholders. The optimal approach uses DFS with memoization to resolve each variable once and handle nested dependencies efficiently. Time: O(n + m), Space: O(m)

Common Approaches

✓ Dependency Resolution DFS

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

Treat each variable as a node in a dependency graph. Use DFS to resolve dependencies recursively, caching results to avoid recomputation. This handles cycles gracefully and is more efficient than iterative replacement.

Iterative Replacement

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

Repeatedly scan through the text and replace any found placeholders with their values from the mapping. Continue until no more replaceholders are found, handling nested substitutions naturally through multiple passes.

Dependency Resolution DFS — Algorithm Steps

Step 1: Build dependency graph from replacement values
Step 2: Use DFS to resolve each variable recursively
Step 3: Cache resolved values and substitute in final text

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Graph

Map variables to their dependencies

DFS Resolve

Recursively resolve each variable once

Substitute

Replace all placeholders with resolved values

Code -

solution.c — C

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

struct KeyValue {
    char key[100];
    char value[1000];
};

struct ResolvedValue {
    char key[100];
    char value[1000];
    int resolved;
};

struct ResolvedValue resolved[50];
int resolvedCount = 0;
int visiting[50];
struct KeyValue* replacements;
int numReplacements;

char* resolve(const char* key) {
    // Check if already resolved
    for (int i = 0; i < resolvedCount; i++) {
        if (strcmp(resolved[i].key, key) == 0) {
            return resolved[i].value;
        }
    }
    
    // Check if currently visiting (cycle)
    int keyIndex = -1;
    for (int i = 0; i < numReplacements; i++) {
        if (strcmp(replacements[i].key, key) == 0) {
            keyIndex = i;
            break;
        }
    }
    
    if (keyIndex == -1 || visiting[keyIndex]) {
        static char result[200];
        sprintf(result, "%%%s%%", key);
        return result;
    }
    
    visiting[keyIndex] = 1;
    static char workValue[2000];
    strcpy(workValue, replacements[keyIndex].value);
    
    // Simple placeholder replacement (not full regex)
    char* pos = workValue;
    while ((pos = strstr(pos, "%"))) {
        char* endPos = strstr(pos + 1, "%");
        if (endPos) {
            char placeholder[100];
            int len = endPos - pos + 1;
            strncpy(placeholder, pos, len);
            placeholder[len] = '\0';
            
            char varName[98];
            strncpy(varName, pos + 1, len - 2);
            varName[len - 2] = '\0';
            
            char* replacement = resolve(varName);
            
            // Replace in workValue
            memmove(pos + strlen(replacement), endPos + 1, strlen(endPos + 1) + 1);
            memcpy(pos, replacement, strlen(replacement));
            pos += strlen(replacement);
        } else {
            break;
        }
    }
    
    visiting[keyIndex] = 0;
    
    // Store resolved value
    strcpy(resolved[resolvedCount].key, key);
    strcpy(resolved[resolvedCount].value, workValue);
    resolvedCount++;
    
    return resolved[resolvedCount - 1].value;
}

char* solution(struct KeyValue* reps, int numReps, char* text) {
    replacements = reps;
    numReplacements = numReps;
    resolvedCount = 0;
    memset(visiting, 0, sizeof(visiting));
    
    // Resolve all variables
    for (int i = 0; i < numReplacements; i++) {
        resolve(replacements[i].key);
    }
    
    // Replace placeholders in final text
    static char result[10000];
    strcpy(result, text);
    
    char* pos = result;
    while ((pos = strstr(pos, "%"))) {
        char* endPos = strstr(pos + 1, "%");
        if (endPos) {
            char varName[98];
            int len = endPos - pos - 1;
            strncpy(varName, pos + 1, len);
            varName[len] = '\0';
            
            // Find resolved value
            char* replacement = NULL;
            for (int i = 0; i < resolvedCount; i++) {
                if (strcmp(resolved[i].key, varName) == 0) {
                    replacement = resolved[i].value;
                    break;
                }
            }
            
            if (replacement) {
                int placeholderLen = endPos - pos + 1;
                memmove(pos + strlen(replacement), endPos + 1, strlen(endPos + 1) + 1);
                memcpy(pos, replacement, strlen(replacement));
                pos += strlen(replacement);
            } else {
                pos = endPos + 1;
            }
        } else {
            break;
        }
    }
    
    return result;
}

int main() {
    char line[2000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    // Simple parsing of {"key":"value",...}
    struct KeyValue reps[50];
    int numReps = 0;
    char* ptr = line;
    while ((ptr = strstr(ptr, "\""))) {
        ptr++;
        char* keyEnd = strstr(ptr, "\"");
        strncpy(reps[numReps].key, ptr, keyEnd - ptr);
        reps[numReps].key[keyEnd - ptr] = '\0';
        ptr = strstr(keyEnd + 1, "\"");
        if (ptr) ptr++;
        char* valueEnd = strstr(ptr, "\"");
        strncpy(reps[numReps].value, ptr, valueEnd - ptr);
        reps[numReps].value[valueEnd - ptr] = '\0';
        numReps++;
        ptr = valueEnd + 1;
    }
    
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    char* result = solution(reps, numReps, line);
    printf("%s\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

Visit each character once and each replacement once during resolution

✓ Linear Growth

Space Complexity

O(m)

Cache for resolved values and recursion stack depth

✓ Linear Space

12.4K Views

Medium Frequency

~15 min Avg. Time

487 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

Dependency Resolution DFS — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler