Tieni traccia di quante volte è stata chiamata una funzione ricorsiva

 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)

Il codice sopra prende un numero intero e lo riduce a una singola cifra moltiplicandolo per le sue stesse cifre.

L'esempio è 39.

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

La console registrerà:

27 
14 
4

Come posso tenere traccia del fatto che la funzione ricorsiva è stata chiamata 3 volte?

Ho provato ad aggiungere un contatore ma non si aggiorna. Gradirei qualsiasi aiuto

Questa è una variante quasi puramente accademica, ma è possibile utilizzare un combinatore a virgola fissa modificato per questo scopo.

Consente di abbreviare e migliorare un po 'la funzione originale:

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

// singleDigit(123234234) == 0

Da questa variante, possiamo fattorizzare ed elaborare il richiamo ricorsivo:

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

Questa funzione può ora essere utilizzata con un combinatore a punto fisso; in particolare ho implementato un combinatore Y adattato per JavaScript (rigoroso) come segue:

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

dove abbiamo Ynormal(singleDigitF, 123234234) == 0.

Ora arriva il trucco. Poiché abbiamo considerato la ricorsione al combinatore Y, possiamo contare il numero di ricorsioni al suo interno:

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

Un rapido controllo nel REPL del nodo fornisce:

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

Questo combinatore ora funzionerà per contare il numero di chiamate in qualsiasi funzione ricorsiva scritta nello stile di singleDigitF.

(Nota che ci sono due fonti per ottenere zero come risposta molto frequente: overflow numerico ( 123345456999999999diventando 123345457000000000ecc.), E il fatto che quasi sicuramente otterrai zero come valore intermedio da qualche parte, quando la dimensione dell'input sta crescendo.)

È necessario aggiungere un argomento contatore alla definizione della funzione:

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

La soluzione tradizionale è passare il conteggio come parametro alla funzione come suggerito da un'altra risposta.

Tuttavia, c'è un'altra soluzione in js. Alcune altre risposte suggeriscono semplicemente di dichiarare il conteggio al di fuori della funzione ricorsiva:

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

Questo ovviamente funziona. Tuttavia, ciò rende la funzione non rientrante (non può essere richiamata due volte correttamente). In alcuni casi puoi ignorare questo problema e assicurarti semplicemente di non chiamare singleDigitdue volte (javascript è a thread singolo, quindi non è troppo difficile da fare) ma questo è un bug in attesa che si verifichi se aggiorni in singleDigitseguito per essere asincrono e sembra anche brutto.

La soluzione è dichiarare la countervariabile all'esterno ma non a livello globale. Questo è possibile perché javascript ha chiusure:

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
}

Questo è simile alla soluzione globale ma ogni volta che chiami singleDigit(che ora non è una funzione ricorsiva) creerà una nuova istanza della countervariabile.

Un altro approccio, poiché si producono tutti i numeri, è quello di utilizzare un generatore.

L'ultimo elemento è il tuo numero nridotto a un numero a una cifra e per contare quante volte hai ripetuto, leggi la lunghezza dell'array.

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>

Pensieri finali

Potresti considerare di avere una condizione di ritorno precoce nella tua funzione. Eventuali numeri con uno zero in esso saranno restituire zero.

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

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

Lo stesso si può dire per qualsiasi numero composto 1solo da.

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

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

Infine, non hai chiarito se accetti solo numeri interi positivi. Se si accettano numeri interi negativi, il loro cast in stringhe può essere rischioso:

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

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

Possibile soluzione:

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

mult(39)
//=> 27

mult(-39)
//=> -27

Ci sono state molte risposte interessanti qui. Penso che la mia versione offra un'ulteriore alternativa interessante.

Fai diverse cose con la tua funzione richiesta. Lo riduci ricorsivamente a una singola cifra. Si registrano i valori intermedi e si desidera un conteggio delle chiamate ricorsive effettuate. Un modo per gestire tutto ciò è scrivere una funzione pura che restituirà una struttura di dati che contiene il risultato finale, i passaggi effettuati e la chiamata contano tutti in uno:

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

È quindi possibile registrare i passaggi, se lo si desidera, o memorizzarli per ulteriori elaborazioni.

Ecco una versione che lo fa:

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

Si noti che seguiamo il stepsma deriviamo il calls. Mentre potremmo tracciare il conteggio delle chiamate con un parametro aggiuntivo, questo sembra non guadagnare nulla. Saltiamo anche il map(Number)passaggio: questi saranno costretti a numeri in ogni caso dalla moltiplicazione.

Se hai dubbi sul fatto che quel stepsparametro predefinito sia esposto come parte dell'API, è abbastanza facile nasconderlo utilizzando una funzione interna come questa:

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 in entrambi i casi, potrebbe essere un po 'più pulito estrarre la moltiplicazione delle cifre in una funzione di supporto:

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 stai solo cercando di contare quante volte viene ridotto e non ti preoccupi specificamente della ricorsione ... puoi semplicemente rimuovere la ricorsione. Il codice seguente rimane fedele alla Posta originale in quanto non viene considerato num <= 9come necessitante riduzione. Pertanto, singleDigit(8)avranno count = 0e singleDigit(39)avranno count = 3, proprio come stanno dimostrando l'OP e la risposta accettata:

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

Non è necessario elaborare i numeri 9 o meno (ad es. num <= 9). Sfortunatamente il codice OP elaborerà num <= 9anche se non lo conta. Il codice sopra non elaborerà né conta num <= 9affatto. Lo passa solo attraverso.

Ho scelto di non usare .reduceperché eseguire la matematica effettiva era molto più veloce da eseguire. E, per me, più facile da capire.

Ulteriore riflessione sulla velocità

Sento che anche il buon codice è veloce. Se stai usando questo tipo di riduzione (che è molto usato in numerologia) potrebbe essere necessario utilizzarlo su una grande quantità di dati. In questo caso, la velocità diventerà la massima importanza.

L'uso di entrambi .map(Number)e console.log(ad ogni passo della riduzione) è molto lungo da eseguire e non necessario. La semplice cancellazione .map(Number)dall'OP lo ha accelerato di circa 4,38x. Eliminazioneconsole.log accelerato così tanto che era quasi impossibile testarlo correttamente (non volevo aspettarlo).

Quindi, simile alla risposta del committente personalizzato , non usare .map(Number)né trasferireconsole.log i risultati in un array e usare .lengthfor countè molto più veloce. Sfortunatamente per la risposta del committente personalizzato , l'utilizzo di una funzione del generatore è davvero molto lento (tale risposta è circa 2,68 volte più lenta dell'OP senza .map(Number)econsole.log )

Inoltre, invece di usare .reduceho appena usato la matematica attuale. Solo questa singola modifica ha velocizzato la mia versione della funzione di un fattore di 3,59x.

Infine, la ricorsione è più lenta, occupa spazio nello stack, utilizza più memoria e ha un limite a quante volte può "ripetersi". Oppure, in questo caso, quanti passaggi di riduzione può utilizzare per completare la riduzione completa. Distribuire la tua ricorsione in loop iterativi mantiene tutto nello stesso posto nello stack e non ha limiti teorici su quanti passi di riduzione può usare per finire. Pertanto, queste funzioni qui possono "ridurre" quasi qualsiasi numero intero di dimensioni, limitato solo dal tempo di esecuzione e dalla lunghezza di un array.

Tutto questo in 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 funzione sopra è estremamente veloce. È circa 3,13 volte più veloce dell'OP (senza .map(Number)e console.log) e circa 8,4 volte più veloce della risposta del committente personalizzato . Tenere presente che l'eliminazione console.logdall'OP impedisce che produca un numero in ogni fase della riduzione. Quindi, la necessità qui di inserire questi risultati in un array.

PT

Perché non effettuare una chiamata console.countnella tua funzione?

Modifica: Snippet da provare nel tuo browser:

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 faccio funzionare in Chrome 79 e Firefox 72

È possibile utilizzare la chiusura per questo.

Basta semplicemente riporlo counternella chiusura della funzione.

Ecco un esempio:

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

Ecco una versione di Python che utilizza una funzione wrapper per semplificare il contatore, come è stato suggerito dalla risposta di slebetman: scrivo questo solo perché l'idea di base è molto chiara in questa implementazione:

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)