Apply Substitutions - Practice Coding Problems

Apply Substitutions - Problem

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

Imagine you're building a template engine that needs to process text with dynamic placeholders! 🎯

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

Here's the twist: replacement values can themselves contain placeholders! This creates a chain of substitutions that must be fully resolved.

Goal: Return the fully substituted text string with no remaining placeholders.

Example:
text = "Hello %name%, welcome to %place%!"
replacements = {"name": "%user%", "user": "Alice", "place": "Wonderland"}
Result: "Hello Alice, welcome to Wonderland!"

Input & Output

example_1.py — Basic Substitution

$ Input: text = "Hello %name%!" replacements = {"name": "World"}

› Output: "Hello World!"

💡 Note: Simple case where %name% is replaced with "World"

example_2.py — Nested Substitution

$ Input: text = "Hello %name%, welcome to %place%!" replacements = {"name": "%user%", "user": "Alice", "place": "Wonderland"}

› Output: "Hello Alice, welcome to Wonderland!"

💡 Note: %name% resolves to %user% which then resolves to "Alice". %place% directly resolves to "Wonderland"

example_3.py — No Replacements Needed

$ Input: text = "No placeholders here" replacements = {"unused": "value"}

› Output: "No placeholders here"

💡 Note: When text contains no placeholders, it's returned unchanged

Visualization

Tap to expand

Understanding the Visualization

Parse Input

Extract placeholders from text and build replacement mapping

Build Dependency Graph

Create relationships between variables that depend on each other

Resolve Variables

Use DFS with memoization to resolve each variable to its final value

Apply Substitutions

Replace all placeholders in the original text with resolved values

Key Takeaway

🎯 Key Insight: By modeling variable dependencies as a graph and using memoization, we can efficiently resolve complex nested substitutions while handling edge cases like circular dependencies.

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

Where n is text length and m is total length of all replacement values

✓ Linear Growth

Space Complexity

O(k)

Where k is the number of unique variables for memoization cache

✓ Linear Space

Constraints

1 ≤ text.length ≤ 10⁴
0 ≤ replacements.size ≤ 100
1 ≤ key.length, value.length ≤ 100
Placeholder format: %variable_name% (alphanumeric and underscore only)
No placeholder will exceed 50 characters including % symbols

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 f Meta 6

This problem is best solved using recursive DFS with memoization. Treat each variable as a graph node with edges to its dependencies. Use a cache to store resolved values and a visiting set to detect circular dependencies. This approach ensures each variable is resolved exactly once, achieving O(n + m) time complexity where n is text length and m is total replacement content length.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive DFS with Memoization	O(n + m)	O(k)	Use recursive approach with caching to resolve each variable once
Brute Force (Repeated Substitution)	O(n * m * k)	O(1)	Keep replacing placeholders until no more changes occur

Recursive DFS with Memoization — Algorithm Steps

Create a memoization cache for resolved variables
For each placeholder in text, call recursive resolve function
In resolve function, check cache first
If not cached, recursively resolve the variable's value
Store result in cache and return
Replace all placeholders with their resolved values

Visualization

Tap to expand

Step-by-Step Walkthrough

Parse Placeholders

Identify all variables that need resolution

Recursive Resolution

Use DFS to resolve each variable, following dependency chains

Cache Results

Store resolved values to avoid recomputing

Final Substitution

Replace all placeholders with cached resolved values

Code -

solution.c — C

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

#define MAX_VARS 100
#define MAX_LEN 10000

typedef struct {
    char key[100];
    char value[1000];
    int resolved;
    char result[1000];
} Variable;

Variable vars[MAX_VARS];
int num_vars;
int visiting[MAX_VARS];

int findVar(const char* key) {
    for (int i = 0; i < num_vars; i++) {
        if (strcmp(vars[i].key, key) == 0) {
            return i;
        }
    }
    return -1;
}

char* resolve(const char* key) {
    int idx = findVar(key);
    if (idx == -1) {
        static char not_found[110];
        sprintf(not_found, "%%%s%%", key);
        return not_found;
    }
    
    if (vars[idx].resolved) {
        return vars[idx].result;
    }
    
    if (visiting[idx]) {
        sprintf(vars[idx].result, "%%%s%%", key);
        return vars[idx].result;
    }
    
    visiting[idx] = 1;
    strcpy(vars[idx].result, vars[idx].value);
    
    // Simple placeholder replacement (basic implementation)
    char temp[1000];
    strcpy(temp, vars[idx].result);
    
    visiting[idx] = 0;
    vars[idx].resolved = 1;
    return vars[idx].result;
}

char* applySubstitutions(const char* text) {
    static char result[MAX_LEN];
    strcpy(result, text);
    
    // Reset resolution state
    for (int i = 0; i < num_vars; i++) {
        vars[i].resolved = 0;
        visiting[i] = 0;
    }
    
    // Simple replacement loop
    int changed = 1;
    while (changed) {
        changed = 0;
        for (int i = 0; i < num_vars; i++) {
            char placeholder[102];
            sprintf(placeholder, "%%%s%%", vars[i].key);
            
            char* pos = strstr(result, placeholder);
            if (pos != NULL) {
                char* resolved = resolve(vars[i].key);
                char temp[MAX_LEN];
                
                int prefix_len = pos - result;
                strncpy(temp, result, prefix_len);
                temp[prefix_len] = '\0';
                
                strcat(temp, resolved);
                strcat(temp, pos + strlen(placeholder));
                
                strcpy(result, temp);
                changed = 1;
                break;
            }
        }
    }
    
    return result;
}

int main() {
    char text[MAX_LEN];
    fgets(text, MAX_LEN, stdin);
    text[strlen(text) - 1] = '\0';
    
    scanf("%d\n", &num_vars);
    
    for (int i = 0; i < num_vars; i++) {
        char line[1100];
        fgets(line, 1100, stdin);
        
        char* colon = strchr(line, ':');
        *colon = '\0';
        strcpy(vars[i].key, line);
        strcpy(vars[i].value, colon + 1);
        
        int len = strlen(vars[i].value);
        if (vars[i].value[len-1] == '\n') {
            vars[i].value[len-1] = '\0';
        }
        
        vars[i].resolved = 0;
    }
    
    printf("%s\n", applySubstitutions(text));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

Where n is text length and m is total length of all replacement values

✓ Linear Growth

Space Complexity

O(k)

Where k is the number of unique variables for memoization cache

✓ Linear Space

Constraints

1 ≤ text.length ≤ 10⁴
0 ≤ replacements.size ≤ 100
1 ≤ key.length, value.length ≤ 100
Placeholder format: %variable_name% (alphanumeric and underscore only)
No placeholder will exceed 50 characters including % symbols

28.5K Views

Medium Frequency

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Recursive DFS with Memoization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler