Codestin Search App

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.

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

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.

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
✓ 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)	O(n * m * k)	O(n)	Check every position in string against every word, then merge overlapping bold regions

Two-Pass with Hash Set — Algorithm Steps

Convert words array to hash set for fast lookup
For each starting position, check all possible substrings
If substring exists in hash set, mark those positions as bold
Merge consecutive bold regions and build result

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Hash Set

Convert words array to hash set for fast lookup

Check Substrings

For each position, check all substrings up to max word length

Hash Lookup

Use O(1) hash lookup instead of linear search

Mark and Build

Mark bold positions and construct result

Code -

solution.c — C

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

typedef struct {
    char* word;
    struct Node* next;
} Node;

int hash(char* word, int size) {
    int sum = 0;
    for (int i = 0; word[i]; i++) {
        sum += word[i];
    }
    return sum % size;
}

bool contains(Node** table, int size, char* word) {
    int index = hash(word, size);
    Node* curr = table[index];
    while (curr) {
        if (strcmp(curr->word, word) == 0) {
            return true;
        }
        curr = curr->next;
    }
    return false;
}

void insert(Node** table, int size, char* word) {
    int index = hash(word, size);
    Node* newNode = malloc(sizeof(Node));
    newNode->word = strdup(word);
    newNode->next = table[index];
    table[index] = newNode;
}

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;
    }
    
    // Create hash table
    int tableSize = 101;
    Node** wordSet = calloc(tableSize, sizeof(Node*));
    int maxLen = 0;
    
    for (int i = 0; i < wordsSize; i++) {
        insert(wordSet, tableSize, words[i]);
        int len = strlen(words[i]);
        if (len > maxLen) maxLen = len;
    }
    
    bool* bold = calloc(n, sizeof(bool));
    char* temp = malloc(maxLen + 1);
    
    // Mark positions
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j <= n && j <= i + maxLen; j++) {
            strncpy(temp, s + i, j - i);
            temp[j - i] = '\0';
            if (contains(wordSet, tableSize, temp)) {
                for (int k = i; k < j; k++) {
                    bold[k] = true;
                }
            }
        }
    }
    
    // Build result
    int resultLen = n + 20; // Estimate
    char* result = malloc(resultLen);
    int pos = 0;
    bool 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);
    free(temp);
    return result;
}

int main() {
    char s[1000];
    fgets(s, sizeof(s), stdin);
    s[strlen(s) - 1] = '\0';
    
    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²)

For each position, we check all possible substrings up to max word length

⚠ Quadratic Growth

Space Complexity

O(m + n)

Hash set for words plus boolean array for positions

⚡ Linearithmic Space

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

Constraints

Visualization

Related Problems

Common Approaches

Two-Pass with Hash Set — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler