Algorithms: Array Techniques

function sliding_maximum(array $a, int $k, array &$output): int {
    alg_require(array_is_list($a));
    alg_require(array_is_list($output));
    $n = count($a);
    alg_require((($n >= 0) && ($n <= 1000000)));
    alg_require((count($a) == $n));
    alg_require((count($output) == alg_add(alg_sub($n, $k), 1)));
    alg_require((($k >= 1) && ($k <= $n)));
    $queue = array_fill(0, alg_size($n), 0);
    $head = 0;
    $tail = 0;
    $i = 0;

    static int next_greater(int[] a, int[] output) {
        java.util.Objects.requireNonNull(a, "a");
        java.util.Objects.requireNonNull(output, "output");
        int n = a.length;
        alg_require(((n >= 0) && (n <= 1000000)));
        alg_require((a.length == n));
        alg_require((output.length == n));
        int[] stack = new int[alg_size(Math.addExact(n, 1))];
        int top = 0;
        int i = 0;
        int index = 0;
        while ((i < n)) {

function next_greater(a, output) {
    alg_require(a instanceof Int32Array);
    alg_require(output instanceof Int32Array);
    let n = a.length;
    alg_require(((n >= 0) && (n <= 1000000)));
    alg_require((a.length == n));
    alg_require((output.length == n));
    let stack = new Int32Array(alg_size(alg_add(n, 1)));
    let top = 0;
    let i = 0;
    let index = 0;
    while ((i < n)) {

def next_greater(a: list[int], output: list[int]) -> int:
    alg_require(isinstance(a, (list, tuple)) and len(a) <= 1000000)
    alg_require(isinstance(output, list) and len(output) <= 1000000)
    n: int = len(a)
    alg_require(n >= 0 and n <= 1000000)
    alg_require(len(a) == n)
    alg_require(len(output) == n)
    stack: list[int] = [0] * alg_size(n + 1)
    top: int = 0
    i: int = 0
    index: int = 0
    while i < n:

int next_greater(const int *a, size_t a_length, int *output, size_t output_length) {
    int alg_error = 0;
    int alg_result = INT_MIN;
    errno = 0;
    int *stack = NULL;
    if (a_length > 1000000 || (a_length && !a)) { errno = EINVAL; alg_result = INT_MIN; goto alg_cleanup; }
    if (output_length > 1000000 || (output_length && !output)) { errno = EINVAL; alg_result = INT_MIN; goto alg_cleanup; }
    int n = (int)a_length;
    if (alg_error) { errno = ERANGE; alg_result = INT_MIN; goto alg_cleanup; }
    if (!(((n >= 0) && (n <= 1000000)))) { errno = EINVAL; alg_result = INT_MIN; goto alg_cleanup; }
    if (alg_error) { errno = ERANGE; alg_result = INT_MIN; goto alg_cleanup; }
    if (!(((int)a_length == n))) { errno = EINVAL; alg_result = INT_MIN; goto alg_cleanup; }