Design Compressed String Iterator - Practice Coding Problems

Design Compressed String Iterator - Problem

Design Compressed String Iterator

You need to create a smart iterator for compressed strings! Imagine you have a string like "a3b2c1" which represents the uncompressed string "aaabbc". Your task is to build an iterator that can traverse through the original uncompressed characters one by one, without actually expanding the entire string.

Your StringIterator class should support:
• next() - Returns the next character in the uncompressed sequence, or a space ' ' if no more characters exist
• hasNext() - Returns true if there are still characters to iterate through

The compressed format: Each letter is followed by a positive integer representing how many times that letter appears consecutively in the original string.

Example: For compressed string "L1e2t1C1o1d1e1", your iterator should return: 'L', 'e', 'e', 't', 'C', 'o', 'd', 'e' in sequence.

Input & Output

example_1.py — Basic Usage

$ Input: StringIterator("L1e2t1C1o1d1e1")

› Output: next() calls return: 'L', 'e', 'e', 't', 'C', 'o', 'd', 'e', then ' '

💡 Note: The compressed string represents 'LeetCode'. Each character is followed by its count. The iterator returns characters one by one in the original sequence.

example_2.py — HasNext Check

$ Input: StringIterator("a3"), check hasNext() before and after exhaustion

› Output: hasNext(): true, next(): 'a', hasNext(): true, next(): 'a', hasNext(): true, next(): 'a', hasNext(): false

💡 Note: The hasNext() method correctly identifies when there are more characters to return. After all 3 'a' characters are consumed, hasNext() returns false.

example_3.py — Empty After Completion

$ Input: StringIterator("x1"), call next() twice

› Output: First next(): 'x', Second next(): ' '

💡 Note: When the iterator is exhausted and next() is called, it returns a space character ' ' as specified in the problem requirements.

Visualization

Tap to expand

Understanding the Visualization

Smart Remote Setup

Initialize with compressed string 'L1e2t1C1o1d1e1' - like a DVD with scene list

Play Current Scene

Start with first scene: 'L' for 1 minute. Remote tracks current scene and time left

Scene Transition

When 'L' scene ends (count=0), automatically load next scene: 'e' for 2 minutes

Memory Efficient

Remote only remembers current scene info, not the entire movie - that's O(1) space!

Key Takeaway

🎯 Key Insight: Like a smart DVD remote, we only need to track the current scene and time remaining, not store the entire movie in memory. This makes the iterator both memory-efficient O(1) and fast O(1) per operation!

Time & Space Complexity

Time Complexity

⏱️

O(1) per operation

Each next() and hasNext() call processes at most one character-count pair

✓ Linear Growth

Space Complexity

O(1)

Only stores current character, count, and position pointers

✓ Linear Space

Constraints

1 ≤ compressedString.length ≤ 1000
compressedString consists of lowercase English letters and digits only
The number following each character is in the range [1, 10⁹]
At most 100 calls will be made to next and hasNext

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 15 f Meta 12

The optimal approach uses on-demand parsing to maintain only the current character and its remaining count in memory. This achieves O(1) space complexity while providing O(1) time for each operation. The key insight is that we don't need to expand the entire string - just track our current position and parse segments as needed.

Common Approaches

Approach	Time	Space	Notes
✓ Optimal On-Demand Parsing	O(1) per operation	O(1)	Parse segments on-demand, keeping only current character and count in memory
Brute Force (Expand All)	O(n) initialization, O(1) per operation	O(n)	Expand the entire compressed string into a list and iterate through it

Optimal On-Demand Parsing — Algorithm Steps

Initialize pointers for compressed string position and current character state
Parse the first character-count pair on initialization
For next(): return current character and decrease its count
When count reaches 0, parse the next character-count pair
For hasNext(): check if current character has remaining count or more segments exist

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Parse first segment: char='L', count=1

Next Call

Return 'L', count becomes 0, parse next segment

Continue

Now char='e', count=2, return 'e'

Efficient

Only current segment data is kept in memory

Code -

solution.c — C

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

typedef struct {
    char* s;
    int i;  // Position in compressed string
    char currentChar;  // Current character
    int count;  // Remaining count for current character
    int length;
} StringIterator;

void parseNext(StringIterator* iterator) {
    if (iterator->i >= iterator->length) {
        iterator->count = 0;
        return;
    }
    
    // Get the character
    iterator->currentChar = iterator->s[iterator->i];
    iterator->i++;
    
    // Parse the count
    iterator->count = 0;
    while (iterator->i < iterator->length && isdigit(iterator->s[iterator->i])) {
        iterator->count = iterator->count * 10 + (iterator->s[iterator->i] - '0');
        iterator->i++;
    }
}

StringIterator* createStringIterator(char* compressedString) {
    StringIterator* iterator = (StringIterator*)malloc(sizeof(StringIterator));
    iterator->s = compressedString;
    iterator->i = 0;
    iterator->length = strlen(compressedString);
    parseNext(iterator);  // Parse first character-count pair
    return iterator;
}

char next(StringIterator* iterator) {
    if (iterator->count <= 0) {
        return ' ';
    }
    
    // Return current character
    char result = iterator->currentChar;
    iterator->count--;
    
    // If current character is exhausted, parse next
    if (iterator->count == 0) {
        parseNext(iterator);
    }
    
    return result;
}

int hasNext(StringIterator* iterator) {
    return iterator->count > 0;
}

int main() {
    StringIterator* iterator = createStringIterator("L1e2t1C1o1d1e1");
    
    while (hasNext(iterator)) {
        printf("%c", next(iterator));
    }
    printf("\n");  // "LeetCode"
    
    free(iterator);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1) per operation

Each next() and hasNext() call processes at most one character-count pair

✓ Linear Growth

Space Complexity

O(1)

Only stores current character, count, and position pointers

✓ Linear Space

Constraints

1 ≤ compressedString.length ≤ 1000
compressedString consists of lowercase English letters and digits only
The number following each character is in the range [1, 10⁹]
At most 100 calls will be made to next and hasNext

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Optimal On-Demand Parsing — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler