Codestin Search App

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.

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

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.

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
✓ 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
Brute Force (Nested Search)	O(n * m * k)	O(n)	Find each keyword occurrence and mark positions individually
Optimized One-Pass Solution	O(n² * k)	O(w + n)	Mark bold positions in single pass using efficient substring matching

Hash Set with Interval Merging — Algorithm Steps

Create a hash set from the keywords array for O(1) lookup
Scan string and find all keyword matches, store as intervals
Sort intervals by start position
Merge overlapping or adjacent intervals
Build final string by inserting bold tags around merged intervals

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Intervals

Use hash set to quickly find all keyword matches as intervals

Sort Intervals

Sort intervals by start position for merging

Merge Overlapping

Combine overlapping or adjacent intervals

Build Result

Construct final string with merged bold regions

Code -

solution.c — C

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

typedef struct {
    int start, end;
} Interval;

int compareIntervals(const void* a, const void* b) {
    return ((Interval*)a)->start - ((Interval*)b)->start;
}

bool isWordInList(char** words, int wordsSize, char* word) {
    for (int i = 0; i < wordsSize; i++) {
        if (strcmp(words[i], word) == 0) {
            return true;
        }
    }
    return false;
}

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;
    }
    
    Interval* intervals = malloc(len * len * sizeof(Interval));
    int intervalCount = 0;
    
    // Find all intervals
    for (int i = 0; i < len; i++) {
        for (int j = i + 1; j <= len; j++) {
            char* substring = malloc(j - i + 1);
            strncpy(substring, s + i, j - i);
            substring[j - i] = '\0';
            
            if (isWordInList(words, wordsSize, substring)) {
                intervals[intervalCount].start = i;
                intervals[intervalCount].end = j - 1;
                intervalCount++;
            }
            free(substring);
        }
    }
    
    if (intervalCount == 0) {
        free(intervals);
        char* result = malloc(len + 1);
        strcpy(result, s);
        return result;
    }
    
    // Sort intervals
    qsort(intervals, intervalCount, sizeof(Interval), compareIntervals);
    
    // Merge intervals
    Interval* merged = malloc(intervalCount * sizeof(Interval));
    int mergedCount = 1;
    merged[0] = intervals[0];
    
    for (int i = 1; i < intervalCount; i++) {
        if (intervals[i].start <= merged[mergedCount - 1].end + 1) {
            if (intervals[i].end > merged[mergedCount - 1].end) {
                merged[mergedCount - 1].end = intervals[i].end;
            }
        } else {
            merged[mergedCount] = intervals[i];
            mergedCount++;
        }
    }
    
    // Build result
    char* result = malloc(len * 10);
    int pos = 0, i = 0;
    
    for (int m = 0; m < mergedCount; m++) {
        // Add non-bold part
        while (i < merged[m].start) {
            result[pos++] = s[i++];
        }
        // Add bold tags
        strcpy(result + pos, "<b>");
        pos += 3;
        while (i <= merged[m].end) {
            result[pos++] = s[i++];
        }
        strcpy(result + pos, "</b>");
        pos += 4;
    }
    
    // Add remaining characters
    while (i < len) {
        result[pos++] = s[i++];
    }
    result[pos] = '\0';
    
    free(intervals);
    free(merged);
    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 * k + m log m)

n = string length, k = max keyword length, m = number of intervals. String scan is O(n*k), sorting intervals is O(m log m)

⚡ Linearithmic

Space Complexity

O(w + m)

w = total characters in all keywords (hash set), m = number of intervals found

✓ Linear Space

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

Constraints

Visualization

Related Problems

Common Approaches

Hash Set with Interval Merging — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler