Bold Words in String - Practice Coding Problems

Bold Words in String - Problem

Bold Words in String

You're working on a text editor that needs to highlight keywords by making them bold. Given an array of words (keywords to highlight) and a string s, your task is to wrap all occurrences of these keywords with  and  tags.

The challenge is to use the minimum number of tags possible. If keywords overlap or are adjacent after bolding, merge their tags into a single ... pair.

Example: If we need to bold "ab" and "bc" in "abcdef", instead of abbcdef, we should return abcdef since they overlap.

Goal: Return the string with properly merged bold tags using the minimum number of tag pairs.

Input & Output

example_1.py — Basic Overlapping

$ Input: words = ["ab", "bc"], s = "aabcd"

› Output: "aabcd"

💡 Note: "ab" matches at position 1-2, "bc" matches at position 2-3. Since they overlap at position 2, we merge them into one bold region covering positions 1-3.

example_2.py — Multiple Separate Regions

$ Input: words = ["ab", "cd"], s = "aabcde"

› Output: "aabcde"

💡 Note: "ab" matches at position 1-2, "cd" matches at position 3-4. They don't overlap, so we create two separate bold regions.

example_3.py — Adjacent Keywords

$ Input: words = ["abc", "123"], s = "aabc123"

› Output: "aabc123"

💡 Note: "abc" matches at position 1-3, "123" matches at position 4-6. Since they're adjacent (position 3 ends, position 4 starts), we merge them into one bold region.

Visualization

Tap to expand

Understanding the Visualization

Identify Keywords

Find all occurrences of keywords in the text - like marking sticky notes

Mark Positions

Mark every character position that should be highlighted

Merge Regions

Combine adjacent or overlapping marked regions into continuous highlights

Apply Tags

Add and tags around each continuous highlighted region

Key Takeaway

🎯 Key Insight: This problem is essentially "Merge Intervals" in disguise! Once you find all keyword matches as intervals, merge overlapping ones and apply bold tags to the merged regions.

Time & Space Complexity

Time Complexity

⏱️

O(n² * k)

n = string length, k = average keyword length. For each position, we check all possible substrings (O(n)), and each substring comparison takes O(k) time.

⚠ Quadratic Growth

Space Complexity

O(w + n)

w = space for hash set of keywords, n = space for boolean array tracking bold positions

⚡ Linearithmic Space

Constraints

1 ≤ words.length ≤ 50
1 ≤ words[i].length ≤ 10
1 ≤ s.length ≤ 500
words[i] and s consist of lowercase English letters only
All strings in words are unique

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal approach uses a hash set for O(1) keyword lookup combined with boolean array marking. The key insight is treating this as an interval merging problem - find all keyword matches as intervals, then merge overlapping ones. Time complexity is O(n²k) where n is string length and k is average keyword length.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Search)	O(n * m * k)	O(n)	Find each keyword occurrence and mark positions individually
Hash Set with Interval Merging	O(n * k + m log m)	O(w + m)	Use hash set for fast keyword lookup, then merge overlapping intervals
Optimized One-Pass Solution	O(n² * k)	O(w + n)	Mark bold positions in single pass using efficient substring matching

Brute Force (Nested Search) — Algorithm Steps

Create a boolean array to track which characters should be bold
For each keyword in the list:
- Scan the string to find all occurrences of this keyword
- Mark corresponding positions as true in the boolean array
Iterate through the boolean array to construct result with tags
Add opening tag when entering a bold region
Add closing tag when leaving a bold region

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create boolean array to track bold positions

Scan Keywords

For each keyword, find all occurrences and mark positions

Build Result

Construct final string with merged bold tags

Code -

solution.c — C

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

char* boldWords(char** words, int wordsSize, char* s) {
    int len = strlen(s);
    if (wordsSize == 0 || len == 0) {
        char* result = malloc(len + 1);
        strcpy(result, s);
        return result;
    }
    
    bool* bold = calloc(len, sizeof(bool));
    
    // Mark all positions that should be bold
    for (int w = 0; w < wordsSize; w++) {
        int wordLen = strlen(words[w]);
        for (int i = 0; i <= len - wordLen; i++) {
            if (strncmp(s + i, words[w], wordLen) == 0) {
                for (int j = i; j < i + wordLen; j++) {
                    bold[j] = true;
                }
            }
        }
    }
    
    // Build result string with tags
    char* result = malloc(len * 10); // Generous allocation
    int pos = 0;
    int i = 0;
    
    while (i < len) {
        if (bold[i]) {
            strcpy(result + pos, "<b>");
            pos += 3;
            while (i < len && bold[i]) {
                result[pos++] = s[i++];
            }
            strcpy(result + pos, "</b>");
            pos += 4;
        } else {
            result[pos++] = s[i++];
        }
    }
    
    result[pos] = '\0';
    free(bold);
    return result;
}

int main() {
    char* words[] = {"ab", "bc"};
    char s[] = "aabcd";
    char* result = boldWords(words, 2, s);
    printf("\"%s\"", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * m * k)

n = string length, m = number of keywords, k = average keyword length. For each keyword, we scan the entire string.

✓ Linear Growth

Space Complexity

O(n)

Boolean array to track which positions should be bold

⚡ Linearithmic Space

Constraints

1 ≤ words.length ≤ 50
1 ≤ words[i].length ≤ 10
1 ≤ s.length ≤ 500
words[i] and s consist of lowercase English letters only
All strings in words are unique

31.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

Brute Force (Nested Search) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler