Bold Words in String

Bold Words in String - Problem

Given an array of keywords words and a string s, make all appearances of all keywords words[i] in s bold.

Any letters between  and  tags become bold.

Return s after adding the bold tags. The returned string should use the least number of tags possible, and the tags should form a valid combination.

Input & Output

Example 1 — Basic Overlapping

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

› Output: "abcabc"

💡 Note: "ab" matches at positions [0,2) and [3,5). "bc" matches at [1,3) and [4,6). Overlapping intervals [0,2) and [1,3) merge to [0,3), and [3,5) and [4,6) merge to [3,6).

Example 2 — No Overlapping

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

› Output: "abcd"

💡 Note: "ab" matches at [0,2) and "cd" matches at [2,4). No overlap, so each gets separate bold tags.

Example 3 — Complete Coverage

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

› Output: "abc"

💡 Note: Single keyword covers entire string, resulting in one bold region.

Constraints

1 ≤ words.length ≤ 1000
1 ≤ words[i].length ≤ 1000
words[i] consists of lowercase English letters only
1 ≤ s.length ≤ 1000
s consists of lowercase English letters only

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 12

The key insight is to merge overlapping bold regions to minimize tag count. The optimal approach uses interval merging - find all keyword positions as intervals, merge overlapping ones, then add bold tags. Time: O(n*m*k + I log I), Space: O(I + n).

Common Approaches

✓ Stack

⏱️ Time: N/A Space: N/A

Brute Force - Mark Each Keyword

⏱️ Time: O(n * m * k) Space: O(n)

For each keyword, scan the entire string to find all occurrences and mark those positions as bold. Then construct the final string by adding bold tags where needed.

Interval Merging Approach

⏱️ Time: O(n * m * k + I log I) Space: O(I + n)

First collect all keyword occurrences as intervals [start, end). Merge overlapping intervals to minimize tag count. Finally build the result string with bold tags around merged intervals.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_WORDS 10000
#define MAX_LEN 100

typedef struct {
    char words[MAX_WORDS][MAX_LEN];
    int count;
} StringSet;

typedef struct {
    StringSet result;
    int index;
} ParseResult;

void addToSet(StringSet* set, const char* word) {
    for (int i = 0; i < set->count; i++) {
        if (strcmp(set->words[i], word) == 0) {
            return;
        }
    }
    if (set->count < MAX_WORDS) {
        strcpy(set->words[set->count], word);
        set->count++;
    }
}

ParseResult parseExpression(const char* s, int start);
ParseResult parseUnion(const char* s, int start);

ParseResult parseExpression(const char* s, int start) {
    StringSet result;
    result.count = 0;
    addToSet(&result, "");
    
    int i = start;
    int len = strlen(s);
    
    while (i < len) {
        if (s[i] == '{') {
            ParseResult unionResult = parseUnion(s, i);
            i = unionResult.index;
            
            StringSet newResult;
            newResult.count = 0;
            
            for (int r = 0; r < result.count; r++) {
                for (int u = 0; u < unionResult.result.count; u++) {
                    char combined[MAX_LEN];
                    strcpy(combined, result.words[r]);
                    strcat(combined, unionResult.result.words[u]);
                    addToSet(&newResult, combined);
                }
            }
            result = newResult;
        } else if (s[i] == '}' || s[i] == ',') {
            break;
        } else {
            char c = s[i];
            for (int r = 0; r < result.count; r++) {
                strncat(result.words[r], &c, 1);
            }
            i++;
        }
    }
    
    ParseResult pr;
    pr.result = result;
    pr.index = i;
    return pr;
}

ParseResult parseUnion(const char* s, int start) {
    int i = start + 1;
    int len = strlen(s);
    StringSet unionResult;
    unionResult.count = 0;
    
    while (i < len && s[i] != '}') {
        ParseResult altResult = parseExpression(s, i);
        i = altResult.index;
        
        for (int a = 0; a < altResult.result.count; a++) {
            addToSet(&unionResult, altResult.result.words[a]);
        }
        
        if (i < len && s[i] == ',') {
            i++;
        }
    }
    
    if (i < len && s[i] == '}') {
        i++;
    }
    
    ParseResult pr;
    pr.result = unionResult;
    pr.index = i;
    return pr;
}

int compare(const void* a, const void* b) {
    return strcmp((char*)a, (char*)b);
}

StringSet solution(char* expression) {
    ParseResult result = parseExpression(expression, 0);
    qsort(result.result.words, result.result.count, sizeof(result.result.words[0]), compare);
    return result.result;
}

int main() {
    char expression[1000];
    fgets(expression, sizeof(expression), stdin);
    expression[strcspn(expression, "\n")] = 0;
    
    StringSet result = solution(expression);
    
    printf("[");
    for (int i = 0; i < result.count; i++) {
        printf("\"%s\"", result.words[i]);
        if (i < result.count - 1) {
            printf(",");
        }
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~25 min Avg. Time

892 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