Design an Ordered Stream - Practice Coding Problems

Design an Ordered Stream - Problem

Design an Ordered Stream - Imagine you're building a streaming data processor that receives key-value pairs out of order but needs to output them in sorted order!

You have a stream of n pairs (idKey, value) arriving in arbitrary order, where:

idKey is an integer between 1 and n
value is a string
No two pairs have the same idKey

Your task is to design a stream that returns values in increasing order of their IDs by returning a chunk (list) of values after each insertion. The key insight is that you should return the largest possible chunk of consecutive values that can be output in order.

Example: If you have slots [1,2,3,4,5] and receive pairs in order: (3,"c"), (1,"a"), (2,"b"), you should output: [], ["a"], ["b","c"] respectively.

Input & Output

example_1.py — Basic Stream

$ Input: OrderedStream os = new OrderedStream(5); os.insert(3, "ccccc"); // Returns [] os.insert(1, "aaaaa"); // Returns ["aaaaa"] os.insert(2, "bbbbb"); // Returns ["bbbbb", "ccccc"] os.insert(5, "eeeee"); // Returns [] os.insert(4, "ddddd"); // Returns ["ddddd", "eeeee"]

› Output: [[], ["aaaaa"], ["bbbbb", "ccccc"], [], ["ddddd", "eeeee"]]

💡 Note: Initially all positions empty. Insert (3,'ccccc') but can't output until we have position 1. Insert (1,'aaaaa') outputs ['aaaaa'] and advances pointer to 2. Insert (2,'bbbbb') finds consecutive 'bbbbb' and 'ccccc' at positions 2,3.

example_2.py — Sequential Insert

$ Input: OrderedStream os = new OrderedStream(3); os.insert(1, "aaa"); // Returns ["aaa"] os.insert(2, "bbb"); // Returns ["bbb"] os.insert(3, "ccc"); // Returns ["ccc"]

› Output: [["aaa"], ["bbb"], ["ccc"]]

💡 Note: When elements arrive in order, each insertion returns a single-element array with that element, as the pointer can advance immediately each time.

example_3.py — Reverse Order

$ Input: OrderedStream os = new OrderedStream(3); os.insert(3, "ccc"); // Returns [] os.insert(2, "bbb"); // Returns [] os.insert(1, "aaa"); // Returns ["aaa", "bbb", "ccc"]

› Output: [[], [], ["aaa", "bbb", "ccc"]]

💡 Note: Elements arrive in reverse order. First two insertions return empty arrays because position 1 is not filled. Final insertion triggers output of all three consecutive elements.

Visualization

Tap to expand

Understanding the Visualization

Order #3 Ready

Kitchen completes order #3 first, but waiter can't serve it until orders #1 and #2 are ready

Order #1 Ready

Kitchen completes order #1, waiter can now serve it immediately

Order #2 Ready

Kitchen completes order #2, waiter can serve both #2 and the waiting #3 consecutively

Key Takeaway

🎯 Key Insight: Like a restaurant waiter tracking the next order to serve, we use a pointer to track the next expected position, avoiding unnecessary rescans of already-processed elements.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each element is visited exactly once when it becomes part of output, so O(n) total for all operations

✓ Linear Growth

Space Complexity

O(n)

Array to store n values plus pointer variable

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 1000
1 ≤ idKey ≤ n
idKey is unique for each call
1 ≤ value.length ≤ 5
value consists only of lowercase letters
At most n calls will be made to insert

Asked in

G Google 12 a Amazon 8 Apple 6 ⊞ Microsoft 4

The optimal solution uses an array with a pointer to track the next expected position. This achieves O(1) amortized time per insertion by only advancing the pointer when consecutive elements are available, avoiding unnecessary rescans of processed elements.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Linear Search Every Time)	O(n²)	O(n)	Store all values and search from beginning every time
Optimal Array with Pointer	O(n)	O(n)	Use array storage with a pointer to track next expected position

Brute Force (Linear Search Every Time) — Algorithm Steps

Initialize an array of size n+1 to store values
On each insert, store the value at the given index
Scan from index 1 to find consecutive non-null values
Return the consecutive sequence and mark those positions as processed

Visualization

Tap to expand

Step-by-Step Walkthrough

Insert (3,'c')

Store value and scan from start - no consecutive sequence from position 1

Insert (1,'a')

Store value and scan from start - find 'a' at position 1

Insert (2,'b')

Store value and scan from start - find 'b','c' consecutive from position 2

Code -

solution.c — C

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

typedef struct {
    char** values;
    int n;
} OrderedStream;

OrderedStream* orderedStreamCreate(int n) {
    OrderedStream* obj = (OrderedStream*)malloc(sizeof(OrderedStream));
    obj->values = (char**)calloc(n + 1, sizeof(char*));
    obj->n = n;
    return obj;
}

char** orderedStreamInsert(OrderedStream* obj, int idKey, char* value, int* returnSize) {
    obj->values[idKey] = strdup(value);
    char** result = (char**)malloc(obj->n * sizeof(char*));
    *returnSize = 0;
    
    // Scan from beginning every time
    int start = 1;
    while (start <= obj->n && obj->values[start] != NULL) {
        if (strcmp(obj->values[start], "PROCESSED") != 0) {
            break;
        }
        start++;
    }
    
    // Collect consecutive values
    while (start <= obj->n && obj->values[start] != NULL && strcmp(obj->values[start], "PROCESSED") != 0) {
        result[*returnSize] = strdup(obj->values[start]);
        free(obj->values[start]);
        obj->values[start] = strdup("PROCESSED");
        (*returnSize)++;
        start++;
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Each insert operation scans up to n elements, and we have n insertions

⚠ Quadratic Growth

Space Complexity

O(n)

Array to store n values plus some variables

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 1000
1 ≤ idKey ≤ n
idKey is unique for each call
1 ≤ value.length ≤ 5
value consists only of lowercase letters
At most n calls will be made to insert

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

Brute Force (Linear Search Every Time) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler