Design an Ordered Stream solution and explanation

class OrderedStream:
    def __init__(self, n: int):
        self.stream = [None] * n
        self.ptr = 0

    def insert(self, idKey: int, value: str) -> list:
        self.stream[idKey - 1] = value
        chunk = []
        while self.ptr < len(self.stream) and self.stream[self.ptr] is not None:
            chunk.append(self.stream[self.ptr])
            self.ptr += 1
        return chunk

import java.util.*;

class OrderedStream {
    private String[] stream;
    private int ptr;
    
    public OrderedStream(int n) {
        stream = new String[n];
        ptr = 0;
    }
    
    public List<String> insert(int idKey, String value) {
        stream[idKey - 1] = value;
        List<String> chunk = new ArrayList<>();
        while (ptr < stream.length && stream[ptr] != null) {
            chunk.add(stream[ptr]);
            ptr++;
        }
        return chunk;
    }
}

#include <vector>
#include <string>

class OrderedStream {

public:
    OrderedStream(int n) {
        stream.resize(n);
        ptr = 0;
    }
    
    std::vector<std::string> insert(int idKey, std::string value) {
        stream[idKey - 1] = value;
        std::vector<std::string> chunk;
        while (ptr < stream.size() && !stream[ptr].empty()) {
            chunk.push_back(stream[ptr]);
            ptr++;
        }
        return chunk;
    }

private:
    std::vector<std::string> stream;
    int ptr;
};

class OrderedStream {
    constructor(n) {
        this.stream = new Array(n);
        this.ptr = 0;
    }

    insert(idKey, value) {
        this.stream[idKey - 1] = value;
        let chunk = [];
        while (this.ptr < this.stream.length && this.stream[this.ptr] !== undefined) {
            chunk.push(this.stream[this.ptr]);
            this.ptr++;
        }
        return chunk;
    }
}

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

typedef struct {
    char **stream;
    int n;
    int ptr;
} OrderedStream;

OrderedStream* orderedStreamCreate(int n) {
    OrderedStream* obj = (OrderedStream*) malloc(sizeof(OrderedStream));
    obj->stream = (char**) calloc(n, sizeof(char*));
    obj->n = n;
    obj->ptr = 0;
    return obj;
}

char **orderedStreamInsert(OrderedStream* obj, int idKey, char *value, int* retSize) {
    obj->stream[idKey - 1] = strdup(value);
    int start = obj->ptr;
    while (start < obj->n && obj->stream[start] != NULL) {
        start++;
    }
    *retSize = start - obj->ptr;
    char **chunk = (char**) malloc((*retSize) * sizeof(char*));
    for (int i = 0; i < *retSize; i++) {
        chunk[i] = obj->stream[obj->ptr + i];
    }
    obj->ptr = start;
    return chunk;
}

void orderedStreamFree(OrderedStream* obj) {
    for (int i = 0; i < obj->n; i++) {
        if (obj->stream[i]) {
            free(obj->stream[i]);
        }
    }
    free(obj->stream);
    free(obj);
}

using System;
using System.Collections.Generic;

public class OrderedStream {
    private string[] stream;
    private int ptr;

    public OrderedStream(int n) {
        stream = new string[n];
        ptr = 0;
    }

    public IList<string> Insert(int idKey, string value) {
        stream[idKey - 1] = value;
        List<string> chunk = new List<string>();
        while (ptr < stream.Length && stream[ptr] != null) {
            chunk.Add(stream[ptr]);
            ptr++;
        }
        return chunk;
    }
}

class OrderedStream:
    def __init__(self, n: int):
        self.stream = {}
        self.ptr = 1
        self.n = n

    def insert(self, idKey: int, value: str) -> list:
        self.stream[idKey] = value
        chunk = []
        while self.ptr <= self.n and self.ptr in self.stream:
            chunk.append(self.stream[self.ptr])
            self.ptr += 1
        return chunk

#include <unordered_map>
#include <vector>
#include <string>

class OrderedStream {
private:
    std::unordered_map<int, std::string> stream;
    int ptr;
    int n;

public:
    OrderedStream(int n) : ptr(1), n(n) {}

    std::vector<std::string> insert(int idKey, std::string value) {
        stream[idKey] = value;
        std::vector<std::string> chunk;
        while (ptr <= n && stream.count(ptr)) {
            chunk.push_back(stream[ptr]);
            ptr++;
        }
        return chunk;
    }
};

class OrderedStream {
    private ptr: number;
    private data: string[];

    constructor(n: number) {
        this.ptr = 1;
        this.data = Array(n + 1);
    }

    insert(idKey: number, value: string): string[] {
        this.data[idKey] = value;
        const ans: string[] = [];
        while (this.data[this.ptr]) {
            ans.push(this.data[this.ptr++]);
        }
        return ans;
    }
}

/**
 * Your OrderedStream object will be instantiated and called as such:
 * var obj = new OrderedStream(n)
 * var param_1 = obj.insert(idKey,value)
 */

type OrderedStream struct {
	ptr  int
	data []string
}

func Constructor(n int) OrderedStream {
	return OrderedStream{
		ptr:  1,
		data: make([]string, n+1),
	}
}

func (this *OrderedStream) Insert(idKey int, value string) []string {
	this.data[idKey] = value
	var ans []string
	for this.ptr < len(this.data) && this.data[this.ptr] != "" {
		ans = append(ans, this.data[this.ptr])
		this.ptr++
	}
	return ans
}

/**
 * Your OrderedStream object will be instantiated and called as such:
 * obj := Constructor(n);
 * param_1 := obj.Insert(idKey,value);
 */

struct OrderedStream {
    ptr: usize,
    data: Vec<Option<String>>,
}

impl OrderedStream {
    fn new(n: i32) -> Self {
        OrderedStream {
            ptr: 1,
            data: vec![None; (n + 1) as usize],
        }
    }

    fn insert(&mut self, id_key: i32, value: String) -> Vec<String> {
        self.data[id_key as usize] = Some(value);
        let mut ans = Vec::new();
        while self.ptr < self.data.len() && self.data[self.ptr].is_some() {
            ans.push(self.data[self.ptr].take().unwrap());
            self.ptr += 1;
        }
        ans
    }
}