1-bit and 2-bit Characters - Practice Coding Problems

1-bit and 2-bit Characters - Problem

Array Easy

1-bit and 2-bit Characters

Imagine you're decoding a binary message that uses a special encoding scheme. In this system, there are only two types of characters:

• 0 represents a 1-bit character
• 10 or 11 represent 2-bit characters

Given a binary array bits that always ends with 0, your task is to determine whether the last character in the decoded message must be the 1-bit character (represented by 0).

The Challenge: Since the array always ends with 0, this final 0 could either be:
1. A standalone 1-bit character, OR
2. The second bit of a 2-bit character that started with 1

Return true if the last character must be a 1-bit character, false otherwise.

Input & Output

example_1.py — Basic Case

$ Input: [1, 0, 0]

› Output: true

💡 Note: Parsing from left: '1' must start a 2-bit character, so we have '10' + '0'. The last character is the 1-bit character '0'.

example_2.py — Two-bit Ending

$ Input: [1, 1, 1, 0]

› Output: false

💡 Note: Parsing from left: '11' (2-bit) + '10' (2-bit). The final '0' is actually the second bit of the last 2-bit character '10', not a standalone 1-bit character.

example_3.py — Single Character

$ Input: [0]

› Output: true

💡 Note: The array contains only one bit '0', which can only represent a 1-bit character.

Visualization

Tap to expand

Understanding the Visualization

Identify the encoding rules

0 = 1-bit character, 10 or 11 = 2-bit characters

Parse from left to right

When you see '1', you must read the next bit too (2-bit char). When you see '0' at start, it's a complete 1-bit character

Track your position

Keep track of where you are after parsing each complete character

Check the final position

If you end exactly at the last bit, it's a 1-bit character. If you overshoot, the last '0' was part of a 2-bit character

Key Takeaway

🎯 Key Insight: The greedy approach works because binary character parsing has a deterministic left-to-right structure - there's exactly one valid way to decode any given sequence.

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

In worst case, we explore 2 possibilities at each position, leading to exponential branching

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth can go up to n levels in worst case

⚡ Linearithmic Space

Constraints

1 ≤ bits.length ≤ 1000
bits[i] is either 0 or 1
The array always ends with 0

Asked in

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

The optimal solution uses a greedy parsing approach in O(n) time. The key insight is that there's only one valid way to decode the array from left to right: when we see '1', it must start a 2-bit character, and when we see '0', it must be a 1-bit character. We parse through the array and check if we end up pointing to the last bit (indicating it's a standalone 1-bit character) or beyond it (indicating it was part of a 2-bit character).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Possible Decodings)	O(2^n)	O(n)	Generate all possible valid decodings and check if any end with a 2-bit character
One-Pass Greedy Parsing (Optimal)	O(n)	O(1)	Parse characters greedily from left to right in a single pass

Brute Force (Try All Possible Decodings) — Algorithm Steps

Start from index 0 and try all possible decodings recursively
At each position, try interpreting current bit as start of 1-bit character (if it's 0)
Also try interpreting current bit as start of 2-bit character (if it's 1)
Keep track of all valid complete decodings
Check if any valid decoding ends with a 2-bit character

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at index 0

Begin exploring all possible ways to decode from the first bit

Branch on possibilities

At each position, try both 1-bit and 2-bit interpretations if valid

Track valid paths

Keep only paths that lead to complete valid decodings

Check final characters

Examine what type of character ends each valid decoding

Code -

solution.c — C

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

bool isOneBitCharacter(int* bits, int bitsSize) {
    int i = 0;
    while (i < bitsSize - 1) {
        if (bits[i] == 1) {
            i += 2; // Skip 2-bit character
        } else {
            i += 1; // Skip 1-bit character
        }
    }
    return i == bitsSize - 1;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    // Simple parsing for array format [1,0,0]
    int bits[100];
    int size = 0;
    char* ptr = input + 1; // Skip '['
    
    while (*ptr != ']' && size < 100) {
        if (*ptr >= '0' && *ptr <= '9') {
            bits[size++] = *ptr - '0';
        }
        ptr++;
    }
    
    printf("%s\n", isOneBitCharacter(bits, size) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

In worst case, we explore 2 possibilities at each position, leading to exponential branching

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth can go up to n levels in worst case

⚡ Linearithmic Space

Constraints

1 ≤ bits.length ≤ 1000
bits[i] is either 0 or 1
The array always ends with 0

28.5K Views

Medium Frequency

~15 min Avg. Time

890 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Possible Decodings) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler