HTML Entity Parser - Practice Coding Problems

HTML Entity Parser - Problem

Imagine you're building a web browser or text editor that needs to display HTML content correctly! HTML Entity Parser is a fundamental text processing problem where you need to convert HTML entities back to their corresponding special characters.

In HTML, certain characters like <, >, &, and quotes have special meanings, so they're encoded as entities to avoid conflicts. Your job is to decode these entities back to readable characters.

The Entity Mappings:
• " → " (Quotation Mark)
• ' → ' (Single Quote)
• & → & (Ampersand)
• > → > (Greater Than)
• < → < (Less Than)
• &frasl; → / (Slash)

Goal: Transform an HTML string by replacing all entities with their actual characters, returning clean, readable text.

Input & Output

example_1.py — Basic HTML Entities

$ Input: text = "& is an HTML entity but &ambassador; is not."

› Output: "& is an HTML entity but &ambassador; is not."

💡 Note: The & entity is converted to & character, while &ambassador; is not a valid entity so it remains unchanged.

example_2.py — Multiple Entities

$ Input: text = "and I quote: "...""

› Output: "and I quote: \"...\""

💡 Note: Both " entities are converted to quotation marks, resulting in proper quote formatting.

example_3.py — Complex Expression

$ Input: text = "Stay home! Practice on Leetcode :)"

› Output: "Stay home! Practice on Leetcode :)"

💡 Note: No entities present in the string, so it returns unchanged. This tests the edge case of no modifications needed.

Constraints

1 ≤ text.length ≤ 10⁵
The string may contain any possible characters out of all the 256 ASCII characters
Only the listed entities need to be replaced - ignore any other & patterns
Entities are case-sensitive and must match exactly

Visualization

Tap to expand

Understanding the Visualization

Scanner Initialization

Start with a hash map of entity codes and begin scanning the input text

Character Processing

Move through each character, building the result string as we go

Entity Detection

When we find '&', check if it starts a valid entity pattern

Smart Replacement

Replace valid entities with their characters, or keep original text if no match

Key Takeaway

🎯 Key Insight: By using a hash table and processing character by character, we achieve optimal O(n) time complexity while handling all entity patterns correctly in a single pass.

Asked in

a Amazon 15 ⊞ Microsoft 12 G Google 8 f Meta 6

The optimal solution uses a one-pass hash table approach with O(n) time complexity. We scan the string character by character, and when we encounter '&', we check against our entity mappings using hash table lookup. This avoids multiple string passes and handles all replacement patterns efficiently in a single traversal.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Multiple String Replacements)	O(n²)	O(n)	Replace each entity one by one using multiple passes
One-Pass Hash Table (Optimal)	O(n)	O(n)	Single pass through string with hash map lookup for entities

Brute Force (Multiple String Replacements) — Algorithm Steps

Create a list of entity-to-character mappings
For each entity type, scan the entire string
Replace all occurrences of that entity with its character
Repeat for all entity types
Return the modified string

Visualization

Tap to expand

Step-by-Step Walkthrough

Original String

Start with the input string containing entities

Replace "

First pass: replace all quotation entities

Replace '

Second pass: replace all apostrophe entities

Continue for all entities

Keep making passes until all entities are replaced

Code -

solution.c — C

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

char* entityParser(char* text) {
    int len = strlen(text);
    char* result = malloc(len + 1);
    strcpy(result, text);
    
    // Replace entities one by one
    char* entities[] = {"&quot;", "&apos;", "&amp;", "&gt;", "&lt;", "&frasl;"};
    char* chars[] = {"\"", "'", "&", ">", "<", "/"};
    
    for (int i = 0; i < 6; i++) {
        char* pos = strstr(result, entities[i]);
        while (pos != NULL) {
            int entityLen = strlen(entities[i]);
            int charLen = strlen(chars[i]);
            memmove(pos + charLen, pos + entityLen, strlen(pos + entityLen) + 1);
            memcpy(pos, chars[i], charLen);
            pos = strstr(pos + charLen, entities[i]);
        }
    }
    
    return result;
}

int main() {
    char text[10000];
    fgets(text, sizeof(text), stdin);
    text[strcspn(text, "\n")] = 0;
    if (text[0] == '"') {
        int len = strlen(text);
        memmove(text, text + 1, len - 2);
        text[len - 2] = '\0';
    }
    char* result = entityParser(text);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We make up to 6 passes through the string, and each replacement operation can be O(n), leading to O(k×n) where k is number of entities

⚠ Quadratic Growth

Space Complexity

O(n)

String operations may create new string objects, requiring O(n) additional space

⚡ Linearithmic Space

24.5K Views

Medium Frequency

~15 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Multiple String Replacements) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler