如何在更高维度上表达递归调用

Question

纯属好奇，不认真。

我知道在JS语言中阶乘运算可以定义成下面的形式

function factorial(n) {
    if (n === 1) return 1;
    return factorial(n - 1) * n;
}

然后我定义了一个factorial of a factorial运算如下形式，并命名为super_factorial_1。维基百科上也有类似的description。

function super_factorial_1(n) {
    if (n === 1) return factorial(1);
    return super_factorial_1(n - 1) * factorial(n);
}

同样，使用super_factorial_1作为运算符，这里定义了super_factorial_2：

function super_factorial_2(n) {
    if (n === 1) return super_factorial_1(1);
    return super_factorial_2(n - 1) * super_factorial_1(n);
}

现在的问题是如何定义super_factorial_n操作，以及super_factorial_n_n，以及super_factorial_n..._n{n of n}。

上面的super_factorial_n操作我是用粗略的方法定义的，但是我觉得这个方法不够好

function super_factorial_n(n, m) {
    const fns = Array(n + 1).fill(0);
    fns[0] = factorial;
    for (let i = 1; i <= n; i++) {
        fns[i] = function (m) {
            if (m === 1) return fns[i - 1](1);
            return fns[i](m - 1) * fns[i - 1](m);
        }
    }
    return fns[n](m);
}

这或许是流程编程范式的一个优化方向。 :)

Answer 1

伪代码

// j is the level number
// i = j - 1
function super_factorial_j(n) {
    if (n === 1)
        return super_factorial_i(1);
    return super_factorial_j(n - 1) * super_factorial_i(n);
}

参数化 j 和 i

function super_factorial(j, n) {
    if (n === 1)
        return super_factorial(j - 1, 1);
    return super_factorial(j, n - 1) * super_factorial(j - 1, n);
}

添加退出条件

function super_factorial(j, n) {
    if (j == 0) { // or j == 1 for one based level number
        if (n === 1)
            return 1;
        return super_factorial(0, n - 1) * n;
    }
    if (n === 1)
        return super_factorial(j - 1, 1);
    return super_factorial(j, n - 1) * super_factorial(j - 1, n);
}

当然，这只是众多方法中的一种。很难说这是否比其他任何一个都好。递归函数通常是堆栈内存消耗。但是这个值可能会增长得非常快，反正用大数字调用它并不是很实际。

如何在更高维度上表达递归调用

How to express recursive calls in higher dimensions

javascript

math

computer-science

paradigms