Acompanhe quantas vezes uma função recursiva foi chamada

 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)

O código acima pega um número inteiro e o reduz para um único dígito multiplicando-o por seus próprios dígitos.

O exemplo é 39.

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

O console registrará:

27 
14 
4

Como faço para acompanhar que a função recursiva foi chamada 3 vezes?

Eu tentei adicionar um contador, mas ele não atualiza. Gostaria de receber qualquer ajuda

Essa é uma variante quase puramente acadêmica, mas você pode usar um combinador de ponto fixo modificado para essa finalidade.

Permite encurtar e melhorar um pouco sua função original:

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

// singleDigit(123234234) == 0

A partir dessa variante, podemos fatorar e curry a chamada recursiva:

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

Esta função agora pode ser usada com um combinador de ponto fixo; especificamente, implementei um combinador Y adaptado para JavaScript (estrito) da seguinte maneira:

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

onde nós temos Ynormal(singleDigitF, 123234234) == 0.

Agora vem o truque. Como fatoramos a recursão no combinador Y, podemos contar o número de recursões dentro dele:

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

Uma verificação rápida no nó REPL fornece:

> 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 agora funcionará para contar o número de chamadas em qualquer função recursiva escrita no estilo de singleDigitF.

(Observe que há duas fontes de obtenção de zero como resposta muito frequente: excesso numérico ( 123345456999999999tornar-se 123345457000000000etc.) e o fato de você quase certamente obter zero como um valor intermediário em algum lugar, quando o tamanho da entrada estiver aumentando.)

Você deve adicionar um contra-argumento à sua definição de função:

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

A solução tradicional é passar a contagem como parâmetro para a função, conforme sugerido por outra resposta.

No entanto, há outra solução em js. Algumas outras respostas sugeridas simplesmente declarando contagem fora da função recursiva:

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

Claro que isso funciona. No entanto, isso torna a função não reentrante (não pode ser chamada duas vezes corretamente). Em alguns casos, você pode ignorar esse problema e simplesmente não ligar singleDigitduas vezes (o javascript é de thread único, por isso não é muito difícil de fazer), mas esse é um bug que está esperando para acontecer se você atualizar singleDigitmais tarde para ser assíncrono e também parecer feio.

A solução é declarar a countervariável fora, mas não globalmente. Isso é possível porque o javascript possui fechamentos:

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
}

Isso é semelhante à solução global, mas cada vez que você chama singleDigit(que agora não é uma função recursiva), ela cria uma nova instância da countervariável.

Outra abordagem, já que você produz todos os números, é usar um gerador.

O último elemento é o seu número nreduzido a um número de dígito e, para contar quantas vezes você iterou, basta ler o comprimento da 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>

Pensamentos finais

Você pode considerar ter uma condição de retorno antecipado em sua função. Quaisquer números com um zero no que irá retornar zero.

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

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

O mesmo pode ser dito para quaisquer números feitos 1apenas.

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

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

Por fim, você não esclareceu se aceita apenas números inteiros positivos. Se você aceitar números inteiros negativos, convertê-los em seqüências de caracteres pode ser arriscado:

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

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

Solução possível:

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

mult(39)
//=> 27

mult(-39)
//=> -27

Houve muitas respostas interessantes aqui. Eu acho que minha versão oferece uma alternativa adicional interessante.

Você faz várias coisas com a função necessária. Você reduz recursivamente para um único dígito. Você registra os valores intermediários e deseja contar as chamadas recursivas feitas. Uma maneira de lidar com tudo isso é escrever uma função pura que retornará uma estrutura de dados que contenha o resultado final, as etapas executadas e a chamada contem tudo em uma:

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

Você pode registrar as etapas, se desejar, ou armazená-las para processamento adicional.

Aqui está uma versão que faz isso:

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))

Observe que rastreamos o, stepsmas derivamos o calls. Embora possamos rastrear a contagem de chamadas com um parâmetro adicional, isso parece não ganhar nada. Também pulamos o map(Number)passo - estes serão coagidos a números em qualquer caso pela multiplicação.

Se você tiver preocupações sobre a stepsexposição desse parâmetro padrão como parte da sua API, é fácil ocultá-lo usando uma função 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, [])
}

E, em ambos os casos, pode ser um pouco mais limpo extrair a multiplicação de dígitos para uma função 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])

Se você está apenas tentando contar quantas vezes ele é reduzido e não se importa especificamente com a recursão ... basta remover a recursão. O código abaixo permanece fiel à postagem original, pois não conta num <= 9como necessitando de redução. Portanto, singleDigit(8)terá count = 0e singleDigit(39)terá count = 3, exatamente como o OP e a resposta aceita estão demonstrando:

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

Não é necessário processar números 9 ou menos (ie. num <= 9). Infelizmente, o código OP será processado num <= 9mesmo que não conte. O código acima não será processado nem contado num <= 9. Apenas passa através.

Eu escolhi não usar .reduceporque fazer as contas reais era muito mais rápido de executar. E, para mim, mais fácil de entender.

Pensando mais sobre velocidade

Eu sinto que um bom código também é rápido. Se você estiver usando esse tipo de redução (que é muito usado em numerologia), pode estar precisando usá-lo em uma grande quantidade de dados. Nesse caso, a velocidade se tornará da maior importância.

O uso de ambos .map(Number)e console.log(em cada etapa de redução) é muito longo para executar e desnecessário. A simples exclusão .map(Number)do OP acelerou em cerca de 4,38x. A exclusão console.logacelerava tanto que era quase impossível testar adequadamente (eu não queria esperar).

Portanto, semelhante à resposta do comando personalizado , não usar .map(Number)nem console.logpressionar os resultados em uma matriz e usar .lengthpara counté muito muito mais rápido. Infelizmente para a resposta do comando personalizado , o uso de uma função de gerador é realmente muito lento (essa resposta é cerca de 2,68x mais lenta que o OP sem .map(Number)e console.log)

Além disso, em vez de usar .reduce, apenas usei a matemática real. Somente essa única mudança acelerou minha versão da função por um fator de 3,59x.

Finalmente, a recursão é mais lenta, ocupa espaço na pilha, usa mais memória e tem um limite de quantas vezes pode "se repetir". Ou, nesse caso, quantas etapas de redução ele pode usar para concluir a redução completa. A distribuição de sua recursão para loops iterativos mantém tudo no mesmo lugar na pilha e não tem limite teórico sobre quantas etapas de redução ele pode usar para concluir. Portanto, essas funções aqui podem "reduzir" praticamente qualquer número inteiro, limitado apenas pelo tempo de execução e por quanto tempo uma matriz pode ser.

Tudo isso em 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

A função acima é extremamente rápida. É cerca de 3,13x mais rápido que o OP (sem .map(Number)e console.log) e 8,4x mais rápido que a resposta do comando personalizado . Lembre-se de que a exclusão console.logdo OP impede a produção de um número a cada etapa da redução. Portanto, a necessidade aqui de empurrar esses resultados em uma matriz.

PT

Por que não ligar console.countna sua função?

Editar: snippet para experimentar no seu 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)

Estou trabalhando no Chrome 79 e Firefox 72

Você pode usar o fechamento para isso.

Simplesmente armazene counterno fechamento da função.

Aqui está um exemplo:

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

Aqui está uma versão do Python que usa uma função wrapper para simplificar o contador, conforme sugerido pela resposta de slebetman - eu escrevo isso apenas porque a ideia principal é muito clara nesta implementação:

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)