Add Bold Tag in String

Add Bold Tag in String - Problem

You are given a string s and an array of strings words. You should add a closed pair of bold tag  and  to wrap the substrings in s that exist in words.

Rules for bold tagging:

If two such substrings overlap, you should wrap them together with only one pair of bold tags
If two substrings wrapped by bold tags are consecutive, you should combine them

Return s after adding the bold tags.

Input & Output

Example 1 — Basic Case

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

› Output: "abcxyz123"

💡 Note: "abc" appears at start (positions 0-2) and "123" appears at end (positions 6-8). Both are wrapped with bold tags separately since they don't overlap.

Example 2 — Overlapping Words

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

› Output: "aaabbcc"

💡 Note: "aaa" matches at 0-2, "aab" matches at 1-3, "bc" matches at 4-5. Since positions 0-5 are all marked bold and consecutive, they merge into one bold tag.

Example 3 — No Matches

$ Input: s = "hello", words = ["world", "test"]

› Output: "hello"

💡 Note: None of the words appear in the string, so no bold tags are added.

Constraints

1 ≤ s.length ≤ 1000
0 ≤ words.length ≤ 100
1 ≤ words[i].length ≤ 100
s and words[i] consist of English letters only

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8

The key insight is to first mark all character positions that should be bold, then merge consecutive regions when building the output. Best approach uses HashSet for O(1) word lookup combined with substring checking. Time: O(n × L²), Space: O(W × L + n).

Common Approaches

✓ Brute Force String Matching

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

For each word in the array, scan through the entire string to find all occurrences and mark the positions that should be bold. Then build the result string by adding bold tags around marked regions.

Optimized with HashSet

⏱️ Time: O(n × L²) Space: O(W × L + n)

Store all words in a HashSet for O(1) lookup time. For each position, check all possible substrings against the set. Mark bold positions and merge consecutive ranges when building the result.

Brute Force String Matching — Algorithm Steps

Create boolean array to track bold positions
For each word, find all occurrences in string
Mark corresponding positions as bold
Build result by adding tags around bold regions

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Matches

Scan for each word and mark positions

Mark Array

Boolean array shows which positions are bold

Build Result

Add tags around consecutive bold regions

Code -

solution.c — C

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

char* solution(char* s, char** words, int wordsSize) {
    int n = strlen(s);
    bool* bold = (bool*)calloc(n, 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 <= n - 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 bold tags
    char* result = (char*)malloc(3 * n + 100); // Extra space for tags
    int pos = 0;
    int i = 0;
    
    while (i < n) {
        if (bold[i]) {
            strcpy(result + pos, "<b>");
            pos += 3;
            while (i < n && bold[i]) {
                result[pos++] = s[i++];
            }
            strcpy(result + pos, "</b>");
            pos += 4;
        } else {
            result[pos++] = s[i++];
        }
    }
    result[pos] = '\0';
    
    free(bold);
    return result;
}

void trim(char* str) {
    char* start = str;
    char* end;
    
    // Trim leading space
    while (isspace(*start)) start++;
    
    // All spaces?
    if (*start == 0) {
        *str = '\0';
        return;
    }
    
    // Trim trailing space
    end = start + strlen(start) - 1;
    while (end > start && isspace(*end)) end--;
    
    // Write new null terminator
    *(end + 1) = '\0';
    
    // Move trimmed string to beginning
    if (start != str) {
        memmove(str, start, strlen(start) + 1);
    }
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char s[1000];
    char words_input[1000];
    
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    fgets(words_input, sizeof(words_input), stdin);
    words_input[strcspn(words_input, "\n")] = 0;
    
    // Parse JSON-like array of strings
    char** words = (char**)malloc(100 * sizeof(char*));
    int wordsSize = 0;
    
    // Remove brackets and parse
    char* content = words_input + 1; // Skip [
    content[strlen(content) - 1] = '\0'; // Remove ]
    
    char* token = strtok(content, ",");
    while (token != NULL && wordsSize < 100) {
        trim(token);
        // Remove quotes
        if (token[0] == '"' && strlen(token) > 1) {
            token++;
            token[strlen(token) - 1] = '\0';
        }
        if (strlen(token) > 0) {
            words[wordsSize] = (char*)malloc(strlen(token) + 1);
            strcpy(words[wordsSize], token);
            wordsSize++;
        }
        token = strtok(NULL, ",");
    }
    
    char* result = solution(s, words, wordsSize);
    printf("%s\n", result);
    
    free(result);
    for (int i = 0; i < wordsSize; i++) {
        free(words[i]);
    }
    free(words);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m × k)

For each word (m), scan entire string (n) and check substring match (k average word length)

✓ Linear Growth

Space Complexity

O(n)

Boolean array to track bold positions for each character

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~25 min Avg. Time

856 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

Brute Force String Matching — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler