Add Bold Tag in String - Practice Coding Problems

Add Bold Tag in String - Problem

Imagine you're building a text editor that needs to highlight search results in a document. You have a string s and an array of words that represent search terms. Your task is to wrap all occurrences of these words in the string with  and  tags.

Here's the challenge: if two highlighted regions overlap or are consecutive, you must merge them into a single bold tag pair. This prevents messy HTML like hello and instead produces clean hello.

Goal: Return the string with properly merged bold tags around all matching substrings.

Input & Output

example_1.py — Basic word matching

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

› Output: "abcxyz"

💡 Note: Only "abc" appears in the string, so we wrap it with bold tags. "123" doesn't appear, so it's ignored.

example_2.py — Overlapping words

$ Input: s = "aaabbcc", words = ["aaa", "aab", "bc"]

› Output: "aaabbcc"

💡 Note: "aaa" matches [0,2], "aab" matches [1,3], "bc" matches [4,5]. Since [0,2] and [1,3] overlap, and [3,4] are adjacent to [4,5], we merge them all into one bold region [0,5].

example_3.py — Separate bold regions

$ Input: s = "cccccccc", words = ["cc", "c"]

› Output: "cccccccc"

💡 Note: Both "c" and "cc" match at multiple overlapping positions throughout the string. All matches overlap, so the entire string becomes one bold region.

Visualization

Tap to expand

Understanding the Visualization

Find Keywords

Scan through the document and identify all keyword positions

Mark Regions

Convert keyword positions into highlight regions (intervals)

Merge Overlaps

Combine overlapping or touching highlight regions

Apply Highlighting

Add bold tags around the final merged regions

Key Takeaway

🎯 Key Insight: Think of this problem as highlighting text in a document - find all matches, then merge overlapping highlights for a clean result.

Time & Space Complexity

Time Complexity

⏱️

O(n * k)

n is string length, k is maximum word length (much better than naive O(n*m*k))

✓ Linear Growth

Space Complexity

O(m + n)

Hash set for words plus interval list

⚡ Linearithmic Space

Constraints

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

Asked in

G Google 42 a Amazon 38 f Meta 25 ⊞ Microsoft 18

The optimal solution uses interval merging technique: find all word matches as intervals, merge overlapping/adjacent ones, then build the result by inserting  tags at interval boundaries. Time complexity: O(n×k) where k is max word length.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Every Position)	O(n * m * k)	O(n)	Check every position in string against every word, then merge overlapping bold regions
Two-Pass with Hash Set	O(n²)	O(m + n)	First pass: build hash set of words, second pass: use efficient string matching
Optimized Interval Merging (Optimal)	O(n * k)	O(m + n)	Mark bold intervals efficiently and merge them in a single pass

Brute Force (Check Every Position) — Algorithm Steps

Create a boolean array to track which characters should be bold
For each position in string, check if any word starts there
Mark all characters of matching words as bold
Merge consecutive bold regions
Build result string with bold tags

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create boolean array to track bold positions

Check Patterns

For each position, check if any word matches

Mark Bold

Mark all characters of matching words as bold

Build Result

Scan marked array and add tags around bold regions

Code -

solution.c — C

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

char* addBoldTag(char* s, char** words, int wordsSize) {
    int n = strlen(s);
    if (n == 0 || wordsSize == 0) {
        char* result = malloc(n + 1);
        strcpy(result, s);
        return result;
    }
    
    bool* bold = calloc(n, sizeof(bool));
    
    // Mark positions that should be bold
    for (int w = 0; w < wordsSize; w++) {
        int wordLen = strlen(words[w]);
        for (int i = 0; i <= n - wordLen; i++) {
            if (strncmp(s + i, words[w], wordLen) == 0) {
                for (int j = i; j < i + wordLen; j++) {
                    bold[j] = true;
                }
            }
        }
    }
    
    // Count result length
    int resultLen = n;
    bool inBold = false;
    for (int i = 0; i < n; i++) {
        if (bold[i] && !inBold) {
            resultLen += 3; // <b>
            inBold = true;
        } else if (!bold[i] && inBold) {
            resultLen += 4; // </b>
            inBold = false;
        }
    }
    if (inBold) resultLen += 4;
    
    char* result = malloc(resultLen + 1);
    int pos = 0;
    inBold = false;
    
    for (int i = 0; i < n; i++) {
        if (bold[i] && !inBold) {
            strcpy(result + pos, "<b>");
            pos += 3;
            inBold = true;
        } else if (!bold[i] && inBold) {
            strcpy(result + pos, "</b>");
            pos += 4;
            inBold = false;
        }
        result[pos++] = s[i];
    }
    
    if (inBold) {
        strcpy(result + pos, "</b>");
        pos += 4;
    }
    result[pos] = '\0';
    
    free(bold);
    return result;
}

int main() {
    char s[1000];
    fgets(s, sizeof(s), stdin);
    s[strlen(s) - 1] = '\0'; // Remove newline
    
    char* words[] = {"ab", "bc"};
    char* result = addBoldTag(s, words, 2);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * m * k)

n is string length, m is number of words, k is average word length

✓ Linear Growth

Space Complexity

O(n)

Boolean array to track bold positions

⚡ Linearithmic Space

Constraints

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

42.0K Views

Medium Frequency

~18 min Avg. Time

1.4K 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 (Check Every Position) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler