UTF-8 Validation - Practice Coding Problems

UTF-8 Validation - Problem

UTF-8 Validation

You're building a text processing system that needs to validate whether incoming byte sequences represent valid UTF-8 encoded text. UTF-8 is the most widely used character encoding on the web, supporting all Unicode characters while maintaining backward compatibility with ASCII.

The Challenge: Given an array of integers representing bytes, determine if they form a valid UTF-8 sequence.

UTF-8 Encoding Rules:
1-byte: 0xxxxxxx (ASCII compatible)
2-byte: 110xxxxx 10xxxxxx
3-byte: 1110xxxx 10xxxxxx 10xxxxxx
4-byte: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx

Each continuation byte must start with 10. The number of leading 1s in the first byte indicates the total character length.

Note: Only the least significant 8 bits of each integer matter.

Input & Output

example_1.py — Valid 2-byte UTF-8 character

$ Input: data = [197, 130, 65]

› Output: true

💡 Note: 197 in binary is 11000101, which matches 110xxxxx (2-byte start). 130 is 10000010, matching 10xxxxxx (continuation). 65 is 01000001, which is valid ASCII. All characters are properly formed.

example_2.py — Invalid continuation byte

$ Input: data = [235, 140, 4]

› Output: false

💡 Note: 235 is 11101011 (3-byte start, needs 2 continuation bytes). 140 is 10001100 (valid continuation). But 4 is 00000100 (not a continuation byte starting with 10). The sequence is invalid.

example_3.py — Incomplete character

$ Input: data = [250, 145, 145]

› Output: false

💡 Note: 250 is 11111010, which doesn't match any valid UTF-8 start pattern (would need 11110xxx for 4-byte). Invalid start byte makes the entire sequence invalid.

Constraints

1 ≤ data.length ≤ 2 × 10⁴
0 ≤ data[i] ≤ 255
Only the least significant 8 bits matter

Visualization

Tap to expand

Understanding the Visualization

Read Chapter Header

Look at the first byte to see if it's a 1, 2, 3, or 4-byte character

Count Expected Pages

Set counter for how many continuation bytes we need

Validate Content Pages

Each continuation byte must start with '10' pattern

Check Completion

All characters must be complete (counter = 0)

Key Takeaway

🎯 Key Insight: Instead of complex pattern matching, use a simple counter to track expected continuation bytes. This transforms a seemingly complex validation into a straightforward state machine.

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 Apple 28

The optimal solution uses a state machine approach with a simple counter to track expected continuation bytes. Instead of complex pattern matching, we maintain one variable that tells us how many 10xxxxxx bytes we're expecting. This achieves O(n) time and O(1) space complexity with clean, readable code.

Common Approaches

Approach	Time	Space	Notes
✓ State Machine Approach (Optimal)	O(n)	O(1)	Track continuation bytes needed using a counter in single pass
Pattern Matching Approach	O(n²)	O(1)	Check each possible UTF-8 pattern at every position

State Machine Approach (Optimal) — Algorithm Steps

Initialize a counter to track expected continuation bytes
For each byte, check if we're expecting a continuation byte
If expecting continuation, validate it's 10xxxxxx and decrement counter
If not expecting continuation, determine how many bytes this character needs
Return true only if counter is zero at the end

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Current State

Are we expecting continuation bytes?

Process Byte

Validate continuation or determine new character length

Update Counter

Decrement for continuation, set for new character

Code -

solution.c — C

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

bool validUtf8(int* data, int dataSize) {
    // Number of continuation bytes expected
    int continuationBytes = 0;
    
    for (int i = 0; i < dataSize; i++) {
        // Get only the least significant 8 bits
        int byte_val = data[i] & 0xFF;
        
        if (continuationBytes > 0) {
            // We're expecting a continuation byte (10xxxxxx)
            if ((byte_val >> 6) != 0b10) {
                return false;
            }
            continuationBytes--;
        } else {
            // This should be a start byte
            if ((byte_val >> 7) == 0) {  // 0xxxxxxx (1-byte)
                continuationBytes = 0;
            } else if ((byte_val >> 5) == 0b110) {  // 110xxxxx (2-byte)
                continuationBytes = 1;
            } else if ((byte_val >> 4) == 0b1110) {  // 1110xxxx (3-byte)
                continuationBytes = 2;
            } else if ((byte_val >> 3) == 0b11110) {  // 11110xxx (4-byte)
                continuationBytes = 3;
            } else {
                return false;  // Invalid start byte
            }
        }
    }
    
    // All characters should be complete
    return continuationBytes == 0;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse the array
    int data[200];
    int size = 0;
    
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        data[size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    printf("%s\n", validUtf8(data, size) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array with constant time operations per element

✓ Linear Growth

Space Complexity

O(1)

Only using a single integer counter for state tracking

✓ Linear Space

38.2K Views

Medium Frequency

~18 min Avg. Time

1.1K 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

State Machine Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler