Evaluate the Bracket Pairs of a String - Practice Coding Problems

Evaluate the Bracket Pairs of a String - Problem

String Template Evaluation Challenge

You're given a template string containing bracket pairs like (name) and (age), along with a knowledge base that maps keys to their values. Your task is to evaluate and replace all bracket pairs with their corresponding values from the knowledge base.

Here's how it works:
• Each bracket pair (key) should be replaced with its corresponding value
• If a key doesn't exist in your knowledge base, replace it with "?"
• No nested brackets exist, so parsing is straightforward

Example: Given string "(name) is (age) years old" and knowledge [["name","Bob"],["age","two"]], the result should be "Bob is two years old".

This is a common pattern in template engines and string interpolation systems!

Input & Output

example_1.py — Basic Template

$ Input: s = "(name)is(age)yearsold" knowledge = [["name","Bob"],["age","two"]]

› Output: "Bobistwoyearsold"

💡 Note: The bracket pair (name) is replaced with "Bob" and (age) is replaced with "two", resulting in "Bobistwoyearsold"

example_2.py — Unknown Key

$ Input: s = "hi(name)" knowledge = [["we","us"]]

› Output: "hi?"

💡 Note: The key "name" is not found in the knowledge array, so (name) is replaced with "?"

example_3.py — Multiple Replacements

$ Input: s = "(a)(a)(a)aaa" knowledge = [["a","yes"]]

› Output: "yesyesyesaaa"

💡 Note: All three bracket pairs (a) are replaced with "yes", while the literal characters "aaa" remain unchanged

Visualization

Tap to expand

Understanding the Visualization

Build Database Index

Convert knowledge array into fast lookup table (hash map)

Scan Template

Process string character by character, identifying bracket pairs

Replace Placeholders

For each bracket pair, extract key and lookup replacement value

Handle Missing Keys

Use '?' for keys not found in knowledge base

Key Takeaway

🎯 Key Insight: Hash tables transform expensive O(k) searches into O(1) lookups, making the overall algorithm linear in the combined input size.

Time & Space Complexity

Time Complexity

⏱️

O(n + k)

O(k) to build hash map + O(n) to process string with O(1) lookups

✓ Linear Growth

Space Complexity

O(k)

Hash map stores k key-value pairs from knowledge array

✓ Linear Space

Constraints

1 ≤ s.length ≤ 10⁵
0 ≤ knowledge.length ≤ 10⁵
knowledge[i].length == 2
1 ≤ knowledge[i][0].length, knowledge[i][1].length ≤ 10
s consists of lowercase English letters and round brackets '(' and ')'
All the keys in knowledge are unique
There are no nested brackets in s

Asked in

G Google 42 a Amazon 38 f Meta 31 ⊞ Microsoft 24

The optimal solution uses a hash table approach with O(n + k) time complexity. First, build a hash map from the knowledge array for O(1) key lookups. Then, scan the string once, extracting keys from bracket pairs and replacing them with hash map values or '?' if not found. This approach is efficient and handles all edge cases perfectly.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Linear Search)	O(n*k)	O(1)	Scan string for brackets, then linear search through knowledge array for each key
Two-Pass Hash Table	O(n + k)	O(k)	Build hash map from knowledge array first, then scan string and lookup keys
One-Pass Hash Table (Optimal)	O(n + k)	O(k)	Build hash map and process string in a single optimized pass

Brute Force (Linear Search) — Algorithm Steps

Iterate through each character in the input string
When finding '(', start extracting the key until ')'
For each extracted key, linear search through knowledge array
Replace the bracket pair with found value or '?' if not found
Continue until entire string is processed

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Bracket Pair

Scan string to find '(' and extract key until ')'

Linear Search

Search through entire knowledge array to find matching key

Replace

Replace bracket pair with found value or '?'

Continue

Move to next character and repeat process

Code -

solution.c — C

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

char* evaluate(char* s, char*** knowledge, int knowledgeSize) {
    int len = strlen(s);
    char* result = malloc(10000 * sizeof(char));
    int resultIdx = 0;
    int i = 0;
    
    while (i < len) {
        if (s[i] == '(') {
            // Find the closing bracket
            int j = i + 1;
            while (j < len && s[j] != ')') {
                j++;
            }
            
            // Extract the key
            int keyLen = j - i - 1;
            char key[keyLen + 1];
            strncpy(key, s + i + 1, keyLen);
            key[keyLen] = '\0';
            
            // Linear search in knowledge
            char* value = "?";
            for (int k = 0; k < knowledgeSize; k++) {
                if (strcmp(knowledge[k][0], key) == 0) {
                    value = knowledge[k][1];
                    break;
                }
            }
            
            strcpy(result + resultIdx, value);
            resultIdx += strlen(value);
            i = j + 1;
        } else {
            result[resultIdx++] = s[i];
            i++;
        }
    }
    
    result[resultIdx] = '\0';
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n*k)

n is string length, k is knowledge array size. For each bracket pair found, we search through entire knowledge array

✓ Linear Growth

Space Complexity

O(1)

Only using variables for iteration, no additional data structures

✓ Linear Space

Constraints

1 ≤ s.length ≤ 10⁵
0 ≤ knowledge.length ≤ 10⁵
knowledge[i].length == 2
1 ≤ knowledge[i][0].length, knowledge[i][1].length ≤ 10
s consists of lowercase English letters and round brackets '(' and ')'
All the keys in knowledge are unique
There are no nested brackets in s

67.3K Views

High Frequency

~15 min Avg. Time

1.8K 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 (Linear Search) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler