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

【问题标题】：How to express recursive calls in higher dimensions如何在更高维度上表达递归调用
【发布时间】：2023-04-02 05:58:01
【问题描述】：

只是一个好奇的问题，并不严重。

在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);
}

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

【问题讨论】：

围绕这些东西的所有理论都存在于分形现实中en.wikipedia.org/wiki/Fractal
"但我认为这种方法不够好。"以及你认为不够好的原因？
@epascarello 这种方式在运行时会生成大量的函数，但是生成这些函数的目的并不是为了实现一个函数工厂，而只是为了使用它们来导出值。所以我认为应该有一种方法来简化这个过程。这类似于我们在为单线程语言添加多线程支持时所面临的困境。
您不需要生成子函数。它们已经参数化。像function super_factorial(n, m) { if (n==0) return 1; if (m==1) return super_factorial(n-1, 1); else return super_factorial(n, m-1); * super_factorial(n-1, m) } 这样的东西。（这不太对，但就是这个想法。在您的讨论之后令人困惑，因为n 在中途改变了含义。）

标签： javascript math computer-science paradigms

【解决方案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);
}

当然，这只是众多方法之一。很难说这是否比其他任何一个更好。递归函数通常会消耗堆栈内存。但是值可能增长很快，无论如何用大数字调用它不是很习惯。

【讨论】：