Tag Validator - Practice Coding Problems

Tag Validator - Problem

String Stack Hard

Imagine you're building a code validator for a markup language parser! Your task is to determine whether a given string represents valid code according to strict formatting rules.

The Challenge: Given a string representing code, validate it according to these rules:

Root Rule: Code must be wrapped in a valid closed tag like <HTML>...</HTML>
Tag Format: <TAG_NAME>CONTENT</TAG_NAME> where opening and closing tags match exactly
Valid Tag Names: Only uppercase letters A-Z, length 1-9 characters
Content Rules: Can contain other valid tags, CDATA sections, or regular text, but NO unmatched brackets or invalid tags
CDATA Sections: <![CDATA[anything goes here]]> - content is treated as literal text, not parsed
No Unmatched Elements: Every < must have a matching >, every opening tag needs its closing tag

Think of it like validating XML/HTML structure, but with stricter rules!

Input & Output

valid_basic.py — Basic Valid Tag

$ Input: code = "<DIV>This is the first line <![CDATA[<div>]]></DIV>"

› Output: true

💡 Note: The code is wrapped in valid

tags, contains text content and a CDATA section with invalid tags inside (which are treated as literal text).

invalid_root.py — Invalid Root

$ Input: code = "<DIV>>> ![cdata[]] <![CDATA[<div>]>]]>]]>>]</DIV>"

› Output: false

💡 Note: While wrapped in DIV tags, the content contains unmatched brackets and malformed CDATA, making it invalid.

invalid_no_root.py — No Root Tag

$ Input: code = "<A> <B> </A> </B>"

› Output: false

💡 Note: The tags are not properly nested - appears before , violating the nested structure rule.

Visualization

Tap to expand

Understanding the Visualization

Start Inspection

Begin with empty checklist, expecting to find opening tag

Opening Tag Found

Add tag to checklist of sections that need to be closed

Handle Special Content

Skip over sealed CDATA boxes without inspecting contents

Closing Tag Found

Check if it matches most recent unclosed section, then mark as complete

Final Validation

Ensure all sections have been properly closed (empty checklist)

Key Takeaway

🎯 Key Insight: The stack naturally maintains the nested structure of tags, ensuring that closing tags match their corresponding opening tags in the correct LIFO order, while CDATA sections are treated as atomic units.

Time & Space Complexity

Time Complexity

⏱️

O(n)

We process each character exactly once, with constant time operations for stack push/pop

✓ Linear Growth

Space Complexity

O(d)

Space proportional to maximum nesting depth d, which is at most O(n) in worst case

✓ Linear Space

Constraints

1 ≤ code.length ≤ 500
code consists of English letters, digits, '<', '>', '/', '!', '[', ']', '.', and ' '.
Valid tag names contain only uppercase letters A-Z with length 1-9
CDATA content can contain any characters between

Asked in

G Google 35 a Amazon 28 ⊞ Microsoft 22 f Meta 18

The optimal solution uses a stack-based approach to validate nested tags in O(n) time. Key insights: track opening tags on a stack, handle CDATA sections atomically without parsing their content, and ensure all tags are properly balanced with valid names (1-9 uppercase letters only).

Common Approaches

Approach	Time	Space	Notes
✓ Stack-Based Parser (Optimal)	O(n)	O(d)	Use a stack to track nested tags and handle CDATA sections efficiently
Brute Force (Recursive Parsing)	O(2^n)	O(n)	Parse every possible interpretation recursively with backtracking

Stack-Based Parser (Optimal) — Algorithm Steps

Initialize a stack to track opening tags
Iterate through the string character by character
When encountering '<', determine if it's CDATA, opening tag, or closing tag
For CDATA, skip to the end marker without parsing content
For opening tags, validate name and push to stack
For closing tags, validate name matches top of stack and pop
Ensure stack has exactly one root tag that encompasses entire string

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with empty stack, begin parsing from left

Opening Tag

Push tag name onto stack when encountering opening tag

CDATA Handling

Skip CDATA content without parsing (if stack not empty)

Closing Tag

Pop from stack and verify it matches the closing tag

Validation

Stack must be empty at end for valid code

Code -

solution.c — C

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

#define MAX_STACK_SIZE 1000
#define MAX_TAG_LEN 10

typedef struct {
    char tags[MAX_STACK_SIZE][MAX_TAG_LEN];
    int top;
} Stack;

void initStack(Stack* s) {
    s->top = -1;
}

void push(Stack* s, const char* tag) {
    if (s->top < MAX_STACK_SIZE - 1) {
        s->top++;
        strcpy(s->tags[s->top], tag);
    }
}

bool pop(Stack* s, char* tag) {
    if (s->top >= 0) {
        strcpy(tag, s->tags[s->top]);
        s->top--;
        return true;
    }
    return false;
}

bool isEmpty(Stack* s) {
    return s->top == -1;
}

char* peek(Stack* s) {
    if (s->top >= 0) {
        return s->tags[s->top];
    }
    return NULL;
}

bool isValidTagName(const char* name, int len) {
    if (len < 1 || len > 9) return false;
    for (int i = 0; i < len; i++) {
        if (name[i] < 'A' || name[i] > 'Z') return false;
    }
    return true;
}

bool isValid(const char* code) {
    int len = strlen(code);
    if (len == 0 || code[0] != '<') return false;
    
    Stack stack;
    initStack(&stack);
    int i = 0;
    
    while (i < len) {
        if (code[i] == '<') {
            // Check for CDATA
            if (i + 9 <= len && strncmp(&code[i], "<![CDATA[", 9) == 0) {
                if (isEmpty(&stack)) return false;
                // Find ]]>
                bool found = false;
                for (int j = i + 9; j <= len - 3; j++) {
                    if (strncmp(&code[j], "]]>", 3) == 0) {
                        i = j + 3;
                        found = true;
                        break;
                    }
                }
                if (!found) return false;
            }
            // Check for closing tag
            else if (i + 1 < len && code[i + 1] == '/') {
                int j = -1;
                for (int k = i + 2; k < len; k++) {
                    if (code[k] == '>') {
                        j = k;
                        break;
                    }
                }
                if (j == -1) return false;
                
                int tagLen = j - i - 2;
                char tagName[MAX_TAG_LEN];
                strncpy(tagName, &code[i + 2], tagLen);
                tagName[tagLen] = '\0';
                
                if (!isValidTagName(tagName, tagLen) || isEmpty(&stack) || strcmp(peek(&stack), tagName) != 0) {
                    return false;
                }
                
                char dummy[MAX_TAG_LEN];
                pop(&stack, dummy);
                i = j + 1;
            }
            // Opening tag
            else {
                int j = -1;
                for (int k = i + 1; k < len; k++) {
                    if (code[k] == '>') {
                        j = k;
                        break;
                    }
                }
                if (j == -1) return false;
                
                int tagLen = j - i - 1;
                char tagName[MAX_TAG_LEN];
                strncpy(tagName, &code[i + 1], tagLen);
                tagName[tagLen] = '\0';
                
                if (!isValidTagName(tagName, tagLen)) return false;
                push(&stack, tagName);
                i = j + 1;
            }
        } else {
            if (isEmpty(&stack)) return false;
            i++;
        }
    }
    
    return isEmpty(&stack);
}

int main() {
    char input[10001];
    if (fgets(input, sizeof(input), stdin)) {
        input[strcspn(input, "\n")] = 0;
        if (input[0] == '"' && input[strlen(input)-1] == '"') {
            input[strlen(input)-1] = 0;
            memmove(input, input+1, strlen(input));
        }
        printf("%s\n", isValid(input) ? "true" : "false");
    }
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We process each character exactly once, with constant time operations for stack push/pop

✓ Linear Growth

Space Complexity

O(d)

Space proportional to maximum nesting depth d, which is at most O(n) in worst case

✓ Linear Space

Constraints

1 ≤ code.length ≤ 500
code consists of English letters, digits, '<', '>', '/', '!', '[', ']', '.', and ' '.
Valid tag names contain only uppercase letters A-Z with length 1-9
CDATA content can contain any characters between

26.5K Views

Medium Frequency

~25 min Avg. Time

850 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

Algorithm Visualization

Pinch to zoom • Tap outside to close

Test Cases

0 passed

0 failed

3 pending

Select Compiler

Choose a programming language

Compiler list would appear here...

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Stack-Based Parser (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler