Mantenga un registro de cuántas veces se llamó a una función recursiva

 function singleDigit(num) {
      let counter = 0
      let number = [...num + ''].map(Number).reduce((x, y) => {return x * y})

      if(number <= 9){
          console.log(number)
      }else{
          console.log(number)
          return singleDigit(number), counter += 1
      }
   }
singleDigit(39)

El código anterior toma un número entero y lo reduce a un solo dígito multiplicándolo por sus propios dígitos.

El ejemplo es 39.

3 x 9 = 27.
2 x 7 = 14.
1 x 4 = 4.

La consola registrará:

27 
14 
4

¿Cómo hago un seguimiento de que la función recursiva se llamó 3 veces?

He intentado agregar un contador pero no se actualiza. Agradecería cualquier ayuda

Esta es una variante casi puramente académica, pero puede usar un combinador de punto fijo modificado para este propósito.

Permite acortar y mejorar un poco tu función original:

function singleDigit(n) {
    let digitProduct = [...(n + '')].reduce((x, y) => x * y, 1);
    return digitProduct <= 9 ? digitProduct : singleDigit(digitProduct);
}

// singleDigit(123234234) == 0

A partir de esta variante, podemos descomponer y cursar la llamada recursiva:

function singleDigitF(recur) {
    return function (n) {
        let digitProduct = [...(n + '')].reduce((x, y) => x * y, 1);
        return digitProduct <= 9 ? digitProduct : recur()(digitProduct);
    };
}

Esta función ahora se puede usar con un combinador de punto fijo; específicamente implementé un combinador Y adaptado para JavaScript (estricto) de la siguiente manera:

function Ynormal(f, ...args) {
    let Y = (g) => g(() => Y(g));
    return Y(f)(...args);
}

donde tenemos Ynormal(singleDigitF, 123234234) == 0.

Ahora viene el truco. Como hemos factorizado la recursividad al combinador Y, podemos contar el número de recursiones dentro de él:

function Ycount(f, ...args) {
    let count = 1;
    let Y = (g) => g(() => {count += 1; return Y(g);});
    return [Y(f)(...args), count];
}

Una comprobación rápida en el Node REPL proporciona:

> Ycount(singleDigitF, 123234234)
[ 0, 3 ]
> let digitProduct = (n) => [...(n + '')].reduce((x, y) => x * y, 1)
undefined
> digitProduct(123234234)
3456
> digitProduct(3456)
360
> digitProduct(360)
0
> Ycount(singleDigitF, 39)
[ 4, 3 ]

Este combinador ahora funcionará para contar el número de llamadas en cualquier función recursiva escrita al estilo de singleDigitF.

(Tenga en cuenta que hay dos fuentes para obtener cero como respuesta muy frecuente: desbordamiento numérico ( 123345456999999999convertirse en 123345457000000000etc.) y el hecho de que casi seguramente obtendrá cero como valor intermedio en algún lugar, cuando el tamaño de la entrada está creciendo).

Debe agregar un argumento contrario a la definición de su función:

function singleDigit(num, counter = 0) {
    console.log(`called ${counter} times`)
    //...
    return singleDigit(number, counter+1)
}
singleDigit(39)

La solución tradicional es pasar el conteo como parámetro a la función como lo sugiere otra respuesta.

Sin embargo, hay otra solución en js. Algunas otras respuestas sugirieron simplemente declarar el recuento fuera de la función recursiva:

let counter = 0
function singleDigit(num) {
  counter++;
  // ..
}

Esto por supuesto funciona. Sin embargo, esto hace que la función no sea reentrante (no se puede llamar dos veces correctamente). En algunos casos, puede ignorar este problema y simplemente asegurarse de no llamar singleDigitdos veces (javascript tiene un solo subproceso, por lo que no es demasiado difícil de hacer), pero este es un error que espera suceder si actualizasingleDigit más tarde para ser asincrónico y también se siente feo.

La solución es declarar la countervariable afuera pero no globalmente. Esto es posible porque JavaScript tiene cierres:

function singleDigit(num) {
  let counter = 0; // outside but in a closure

  // use an inner function as the real recursive function:
  function recursion (num) {
    counter ++
    let number = [...num + ''].map(Number).reduce((x, y) => {return x * y})

    if(number <= 9){
      return counter            // return final count (terminate)
    }else{
      return recursion(number)  // recurse!
    }
  }

  return recursion(num); // start recursion
}

Esto es similar a la solución global, pero cada vez que llame singleDigit(que ahora no es una función recursiva) creará una nueva instancia de la countervariable.

Otro enfoque, ya que produce todos los números, es usar un generador.

El último elemento es su número nreducido a un número de un solo dígito y para contar cuántas veces ha iterado, solo lea la longitud de la matriz.

const digits = [...to_single_digit(39)];
console.log(digits);
//=> [27, 14, 4]

<script>
function* to_single_digit(n) {
  do {
    n = [...String(n)].reduce((x, y) => x * y);
    yield n;
  } while (n > 9);
}
</script>

Pensamientos finales

Es posible que desee considerar tener una condición de retorno temprano en su función. Cualquier número con un cero en ella se devolverá cero.

singleDigit(1024);       //=> 0
singleDigit(9876543210); //=> 0

// possible solution: String(n).includes('0')

Lo mismo puede decirse de cualquier número compuesto 1únicamente.

singleDigit(11);    //=> 1
singleDigit(111);   //=> 1
singleDigit(11111); //=> 1

// possible solution: [...String(n)].every(n => n === '1')

Finalmente, no aclaró si acepta solo enteros positivos. Si acepta enteros negativos, convertirlos en cadenas puede ser arriesgado:

[...String(39)].reduce((x, y) => x * y)
//=> 27

[...String(-39)].reduce((x, y) => x * y)
//=> NaN

Solución posible:

const mult = n =>
  [...String(Math.abs(n))].reduce((x, y) => x * y, n < 0 ? -1 : 1)

mult(39)
//=> 27

mult(-39)
//=> -27

Ha habido muchas respuestas interesantes aquí. Creo que mi versión ofrece una alternativa interesante adicional.

Haces varias cosas con tu función requerida. Lo reduce recursivamente a un solo dígito. Registra los valores intermedios y desea contar las llamadas recursivas realizadas. Una forma de manejar todo esto es escribir una función pura que devolverá una estructura de datos que contenga el resultado final, los pasos tomados y el recuento de llamadas, todo en uno:

  {
    digit: 4,
    steps: [39, 27, 14, 4],
    calls: 3
  }

Luego puede registrar los pasos si lo desea, o almacenarlos para su posterior procesamiento.

Aquí hay una versión que hace eso:

const singleDigit = (n, steps = []) =>
  n <= 9
    ? {digit: n, steps: [... steps, n], calls: steps .length}
    : singleDigit ([... (n + '')] .reduce ((a, b) => a * b), [... steps, n])

console .log (singleDigit (39))

Tenga en cuenta que rastreamos el stepspero derivamos el calls. Si bien podríamos rastrear el conteo de llamadas con un parámetro adicional, eso parece no ganar nada. También nos saltamos elmap(Number) paso: estos se convertirán en números en cualquier caso mediante la multiplicación.

Si le preocupa que ese stepsparámetro predeterminado se exponga como parte de su API, es bastante fácil ocultarlo utilizando una función interna como esta:

const singleDigit = (n) => {
  const recur = (n, steps) => 
    n <= 9
      ? {digit: n, steps: [... steps, n], calls: steps .length}
      : recur ([... (n + '')] .reduce ((a, b) => a * b), [... steps, n])
  return recur (n, [])
}

Y en cualquier caso, podría ser un poco más limpio extraer la multiplicación de dígitos en una función auxiliar:

const digitProduct = (n) => [... (n + '')] .reduce ((a, b) => a * b)

const singleDigit = (n, steps = []) =>
  n <= 9
    ? {digit: n, steps: [... steps, n], calls: steps .length}
    : singleDigit (digitProduct(n), [... steps, n])

Si solo está tratando de contar cuántas veces se reduce y no le importa la recursión específicamente ... simplemente puede eliminarla. El siguiente código permanece fiel a la publicación original, ya que no cuenta num <= 9como una necesidad de reducción. Por lo tanto, singleDigit(8)tendrá count = 0y singleDigit(39)tendrá count = 3, al igual que el OP y la respuesta aceptada demuestran:

const singleDigit = (num) => {
    let count = 0, ret, x;
    while (num > 9) {
        ret = 1;
        while (num > 9) {
            x = num % 10;
            num = (num - x) / 10;
            ret *= x;
        }
        num *= ret;
        count++;
        console.log(num);
    }
    console.log("Answer = " + num + ", count = " + count);
    return num;
}

No es necesario procesar los números 9 o menos (es decir num <= 9). Lamentablemente, el código OP se procesará num <= 9aunque no lo cuente. El código anterior no procesará ni contaránum <= 9 en absoluto. Simplemente lo pasa a través.

Elijo no usarlo .reduceporque hacer las matemáticas reales fue mucho más rápido de ejecutar. Y, para mí, más fácil de entender.

Más pensamiento sobre la velocidad

Siento que un buen código también es rápido. Si está utilizando este tipo de reducción (que se usa mucho en numerología), es posible que necesite usarlo en una gran cantidad de datos. En este caso, la velocidad se convertirá en la más importante.

Usar ambos .map(Number)y console.log(en cada paso de reducción) son muy largos de ejecutar e innecesarios. Simplemente eliminar .map(Number)del OP lo aceleró en aproximadamente 4.38x. La eliminación lo console.logaceleró tanto que era casi imposible probarlo adecuadamente (no quería esperar).

Entonces, de manera similar a la respuesta de customcommander , no usar .map(Number)ni console.logempujar los resultados a una matriz y usar .lengthfor countes mucho más rápido. Desafortunadamente para la respuesta de customcommander , el uso de una función de generador es realmente muy lento (esa respuesta es aproximadamente 2.68 veces más lenta que el OP sin .map(Number)y console.log)

Además, en lugar de usar .reduce, solo utilicé las matemáticas reales. Este solo cambio aceleró mi versión de la función en un factor de 3.59x.

Finalmente, la recursividad es más lenta, ocupa espacio en la pila, usa más memoria y tiene un límite de cuántas veces puede "repetirse". O, en este caso, cuántos pasos de reducción puede usar para finalizar la reducción completa. El despliegue de su recursión a bucles iterativos lo mantiene todo en el mismo lugar en la pila y no tiene un límite teórico sobre cuántos pasos de reducción puede usar para terminar. Por lo tanto, estas funciones aquí pueden "reducir" casi cualquier número entero de cualquier tamaño, solo limitado por el tiempo de ejecución y el tiempo que puede durar una matriz.

Todo esto en mente ...

const singleDigit2 = (num) => {
    let red, x, arr = [];
    do {
        red = 1;
        while (num > 9) {
            x = num % 10;
            num = (num - x) / 10;
            red *= x;
        }
        num *= red;
        arr.push(num);
    } while (num > 9);
    return arr;
}

let ans = singleDigit2(39);
console.log("singleDigit2(39) = [" + ans + "],  count = " + ans.length );
 // Output: singleDigit2(39) = [27,14,4],  count = 3

La función anterior se ejecuta extremadamente rápido. Es aproximadamente 3.13 veces más rápido que el OP (sin .map(Number)y console.log) y aproximadamente 8.4 veces más rápido que la respuesta de customcommander . Tenga en cuenta que eliminar console.logdel OP evita que produzca un número en cada paso de reducción. Por lo tanto, la necesidad aquí de llevar estos resultados a una matriz.

PT

¿Por qué no hacer una llamada console.counten su función?

Editar: Fragmento para probar en su navegador:

function singleDigit(num) {
    console.count("singleDigit");

    let counter = 0
    let number = [...num + ''].map(Number).reduce((x, y) => {return x * y})

    if(number <= 9){
        console.log(number)
    }else{
        console.log(number)
        return singleDigit(number), counter += 1
    }
}
singleDigit(39)

Lo tengo trabajando en Chrome 79 y Firefox 72

Puedes usar el cierre para esto.

Simplemente almacene counteren el cierre de la función.

Aquí hay un ejemplo:

function singleDigitDecorator() {
	let counter = 0;

	return function singleDigitWork(num, isCalledRecursively) {

		// Reset if called with new params 
		if (!isCalledRecursively) {
			counter = 0;
		}

		counter++; // *

		console.log(`called ${counter} times`);

		let number = [...(num + "")].map(Number).reduce((x, y) => {
			return x * y;
		});

		if (number <= 9) {
			console.log(number);
		} else {
			console.log(number);

			return singleDigitWork(number, true);
		}
	};
}

const singleDigit = singleDigitDecorator();

singleDigit(39);

console.log('`===========`');

singleDigit(44);

Aquí hay una versión de Python que usa una función de contenedor para simplificar el contador, como ha sido sugerido por la respuesta de slebetman: escribo esto solo porque la idea central es muy clara en esta implementación:

from functools import reduce

def single_digit(n: int) -> tuple:
    """Take an integer >= 0 and return a tuple of the single-digit product reduction
    and the number of reductions performed."""

    def _single_digit(n, i):
        if n <= 9:
            return n, i
        else:
            digits = (int(d) for d in str(n))
            product = reduce(lambda x, y: x * y, digits)
            return _single_digit(product, i + 1)

    return _single_digit(n, 0)

>>> single_digit(39)
(4, 3)