Template Engine - Problem

Build a simple template engine that replaces {{variable}} placeholders with provided values.

Given a template string containing placeholders in the format {{variableName}} and a dictionary of variable values, replace all placeholders with their corresponding values.

Requirements:

Replace all {{variableName}} with the value from the variables dictionary
If a variable is not found in the dictionary, leave the placeholder unchanged
Variable names can contain letters, numbers, and underscores
Nested braces like {{{var}}} should be handled correctly

Input & Output

Example 1 — Basic Template

$ Input: template = "Hello {{name}}, welcome to {{city}}!", variables = {"name": "Alice", "city": "Paris"}

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

💡 Note: Both {{name}} and {{city}} are replaced with their corresponding values from the variables dictionary

Example 2 — Missing Variable

$ Input: template = "Hi {{name}}, your score is {{score}}", variables = {"name": "Bob"}

› Output: "Hi Bob, your score is {{score}}"

💡 Note: {{name}} is replaced with 'Bob', but {{score}} remains unchanged since it's not in the variables dictionary

Example 3 — No Variables

$ Input: template = "Welcome to our website!", variables = {}

› Output: "Welcome to our website!"

💡 Note: Template has no placeholders, so the original string is returned unchanged

Constraints

1 ≤ template.length ≤ 1000
0 ≤ variables.size() ≤ 100
Variable names contain only letters, numbers, and underscores
Variable values are strings

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15

The key insight is to process the template in a single pass, building the result string character by character. When we encounter {{, we collect the variable name and immediately replace it if found in the dictionary. Best approach is single pass parsing with Time: O(n), Space: O(n).

Common Approaches

✓ Brute Force - Repeated Search

⏱️ Time: O(n²) Space: O(n)

Keep searching the string for {{variable}} patterns from the beginning each time. When found, replace the first occurrence and start over. Continue until no more patterns exist.

Single Pass with String Builder

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

Scan through the template once, building the result string as we go. When we encounter '{{', collect characters until '}}' and perform replacement immediately.

Brute Force - Repeated Search — Algorithm Steps

Step 1: Search entire string for first {{}} pattern
Step 2: If found, replace with variable value and restart from beginning
Step 3: Repeat until no more patterns found

Visualization

Tap to expand

Step-by-Step Walkthrough

First Scan

Find first {{name}} pattern and replace

Restart Scan

Start over from beginning to find next pattern

Repeat

Continue until no patterns remain

Code -

solution.c — C

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

char* solution(char* template, char variables[][2][100], int var_count) {
    char* result = malloc(1000 * sizeof(char));
    strcpy(result, template);
    
    int changed = 1;
    while (changed) {
        changed = 0;
        for (int i = 0; i < var_count; i++) {
            char pattern[110];
            sprintf(pattern, "{{%s}}", variables[i][0]);
            char* pos = strstr(result, pattern);
            if (pos != NULL) {
                char* new_result = malloc(1000 * sizeof(char));
                int prefix_len = pos - result;
                strncpy(new_result, result, prefix_len);
                new_result[prefix_len] = '\0';
                strcat(new_result, variables[i][1]);
                strcat(new_result, pos + strlen(pattern));
                strcpy(result, new_result);
                free(new_result);
                changed = 1;
                break;
            }
        }
    }
    return result;
}

int main() {
    char template[1000];
    fgets(template, sizeof(template), stdin);
    template[strcspn(template, "\n")] = 0;
    
    char variables[10][2][100];
    int var_count = 0;
    
    char variables_json[1000];
    fgets(variables_json, sizeof(variables_json), stdin);
    
    // Simple parsing for {"key":"value","key2":"value2"}
    char* ptr = variables_json + 1; // skip {
    while (*ptr != '}' && var_count < 10) {
        if (*ptr == '"') {
            ptr++;
            int i = 0;
            while (*ptr != '"') variables[var_count][0][i++] = *ptr++;
            variables[var_count][0][i] = '\0';
            ptr += 3; // skip ":"  
            i = 0;
            while (*ptr != '"') variables[var_count][1][i++] = *ptr++;
            variables[var_count][1][i] = '\0';
            var_count++;
            ptr++;
            if (*ptr == ',') ptr++;
        } else {
            ptr++;
        }
    }
    
    char* result = solution(template, variables, var_count);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each variable replacement, we scan the entire string from the beginning

⚠ Quadratic Growth

Space Complexity

O(n)

Creating new strings for each replacement operation

⚡ Linearithmic Space

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

Template Engine - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Repeated Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler