Cuestión de curiosidad, nada serio.
En el lenguaje JS sé que una operación factorial se puede definir de la siguiente forma.
function factorial(n) { if (n === 1) return 1; return factorial(n - 1) * n; } Luego definí un factorial de una operación factorial de la siguiente forma y lo llamé super_factorial_1 . Hay una descripción similar en Wikipedia.
function super_factorial_1(n) { if (n === 1) return factorial(1); return super_factorial_1(n - 1) * factorial(n); } De manera similar, usando el super_factorial_1 como operador, el super_factorial_2 se define aquí:
function super_factorial_2(n) { if (n === 1) return super_factorial_1(1); return super_factorial_2(n - 1) * super_factorial_1(n); } Ahora la pregunta es cómo definir la operación super_factorial_n , y la super_factorial_n_n , y además, la super_factorial_n..._n{n of n} .
He usado un método tosco para definir la operación super_factorial_n anterior, pero no creo que este método sea lo suficientemente bueno.
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); }Quizás esta sea una dirección de optimización para el paradigma de programación de procesos. :)
El pseudocódigo
// 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); } Parametrizar j e 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); }Agregar la condición de salida
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); }Por supuesto, este es solo uno de los muchos caminos a seguir. Y es difícil decir si esto es mejor que cualquier otro. Las funciones recursivas generalmente consumen memoria de pila. Pero es probable que el valor crezca muy rápido, de todos modos no es muy práctico llamarlo con números grandes.