Gardez une trace du nombre de fois qu'une fonction récursive a été appelée

 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)

Le code ci-dessus prend un entier et le réduit à un seul chiffre en le multipliant par ses propres chiffres.

L'exemple est 39.

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

La console enregistrera:

27 
14 
4

Comment savoir si la fonction récursive a été appelée 3 fois?

J'ai essayé d'ajouter un compteur mais il ne se met pas à jour. J'apprécierais toute aide

Il s'agit d'une variante presque purement académique, mais vous pouvez utiliser un combinateur à virgule fixe modifié à cet effet.

Permet de raccourcir et d'améliorer un peu votre fonction d'origine:

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

// singleDigit(123234234) == 0

À partir de cette variante, nous pouvons factoriser et curry l'appel récursif:

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

Cette fonction peut désormais être utilisée avec un combinateur à virgule fixe; spécifiquement, j'ai implémenté un combinateur Y adapté pour (strict) JavaScript comme suit:

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

où nous avons Ynormal(singleDigitF, 123234234) == 0.

Maintenant vient le tour. Puisque nous avons factorisé la récursivité vers le combinateur Y, nous pouvons compter le nombre de récursions en son sein:

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

Une vérification rapide dans le Node REPL donne:

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

Ce combinateur fonctionnera maintenant pour compter le nombre d'appels dans n'importe quelle fonction récursive écrite dans le style de singleDigitF.

(Notez qu'il existe deux sources d'obtention de zéro comme réponse très fréquente: le débordement numérique ( 123345456999999999devenant 123345457000000000etc.) et le fait que vous obtiendrez presque sûrement zéro comme valeur intermédiaire quelque part, lorsque la taille de l'entrée augmente.)

Vous devez ajouter un argument de compteur à votre définition de fonction:

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

La solution traditionnelle consiste à passer le compte en tant que paramètre à la fonction comme suggéré par une autre réponse.

Cependant, il existe une autre solution dans js. Quelques autres réponses suggèrent simplement de déclarer le nombre en dehors de la fonction récursive:

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

Cela fonctionne bien sûr. Cependant, cela rend la fonction non réentrante (ne peut pas être appelée deux fois correctement). Dans certains cas, vous pouvez ignorer ce problème et assurez-vous simplement de ne pas appeler singleDigitdeux fois (javascript est un thread unique donc ce n'est pas trop difficile à faire), mais c'est un bug qui attend de se produire si vous mettez singleDigità jour plus tard pour être asynchrone et il se sent également laid.

La solution consiste à déclarer la countervariable à l'extérieur mais pas globalement. Ceci est possible car javascript a des fermetures:

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
}

Ceci est similaire à la solution globale mais chaque fois que vous appelez singleDigit(ce qui n'est plus une fonction récursive), cela créera une nouvelle instance de la countervariable.

Une autre approche, puisque vous produisez tous les nombres, consiste à utiliser un générateur.

Le dernier élément est votre nombre nréduit à un nombre à un seul chiffre et pour compter le nombre de fois que vous l'avez répété, il suffit de lire la longueur du tableau.

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>

Dernières pensées

Vous voudrez peut-être envisager d'avoir une condition de retour précoce dans votre fonction. Tous les chiffres avec un zéro dans ce sera revenir à zéro.

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

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

La même chose peut être dite pour tous les numéros composés 1uniquement de.

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

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

Enfin, vous n'avez pas précisé si vous n'acceptez que des entiers positifs. Si vous acceptez des entiers négatifs, les convertir en chaînes peut être risqué:

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

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

Solution possible:

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

mult(39)
//=> 27

mult(-39)
//=> -27

Il y a eu beaucoup de réponses intéressantes ici. Je pense que ma version offre une alternative intéressante supplémentaire.

Vous faites plusieurs choses avec votre fonction requise. Vous le réduisez récursivement à un seul chiffre. Vous enregistrez les valeurs intermédiaires et vous souhaitez un décompte des appels récursifs effectués. Une façon de gérer tout cela est d'écrire une fonction pure qui renverra une structure de données qui contient le résultat final, les étapes prises et le nombre d'appels en un seul:

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

Vous pouvez ensuite enregistrer les étapes si vous le souhaitez ou les stocker pour un traitement ultérieur.

Voici une version qui fait ça:

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

Notez que nous suivons le stepsmais dérivons le calls. Bien que nous puissions suivre le nombre d'appels avec un paramètre supplémentaire, cela ne semble rien gagner. Nous sautons également l' map(Number)étape - ceux-ci seront de toute façon contraints aux nombres par la multiplication.

Si vous craignez que ce stepsparamètre par défaut soit exposé dans le cadre de votre API, il est assez facile de le masquer en utilisant une fonction interne comme celle-ci:

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, [])
}

Et dans les deux cas, il pourrait être un peu plus propre d'extraire la multiplication des chiffres dans une fonction d'assistance:

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 vous essayez simplement de compter combien de fois il est réduit et que vous ne vous souciez pas spécifiquement de la récursivité ... vous pouvez simplement supprimer la récursivité. Le code ci-dessous reste fidèle à la poste d'origine car il ne compte pas num <= 9comme nécessitant une réduction. Par conséquent, singleDigit(8)aura count = 0, et singleDigit(39)aura count = 3, tout comme le PO et la réponse acceptée démontrent:

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

Il n'est pas nécessaire de traiter les nombres 9 ou moins (c.-à-d. num <= 9). Malheureusement, le code OP sera traité num <= 9même s'il ne le compte pas. Le code ci-dessus ne traitera ni ne comptera pas num <= 9du tout. Il passe juste à travers.

J'ai choisi de ne pas l'utiliser, .reducecar l'exécution des calculs réels était beaucoup plus rapide à exécuter. Et, pour moi, plus facile à comprendre.

Réflexion sur la vitesse

Je pense que le bon code est également rapide. Si vous utilisez ce type de réduction (qui est beaucoup utilisé en numérologie), vous devrez peut-être l'utiliser sur une énorme quantité de données. Dans ce cas, la vitesse deviendra de la plus haute importance.

L'utilisation des deux .map(Number)et console.log(à chaque étape de réduction) est à la fois très très longue à exécuter et inutile. La simple suppression .map(Number)de l'OP l'a accéléré d'environ 4,38x. La suppression console.loga tellement accéléré qu'il était presque impossible de tester correctement (je ne voulais pas l'attendre).

Donc, comme pour la réponse de customcommander , ne pas utiliser .map(Number)ni console.loget pousser les résultats dans un tableau et utiliser .lengthfor countest beaucoup plus rapide. Malheureusement pour la réponse de customcommander , l'utilisation d'une fonction de générateur est vraiment très lente (cette réponse est environ 2.68x plus lente que l'OP sans .map(Number)et console.log)

En outre, au lieu d'utiliser, .reduceje viens d'utiliser les mathématiques réelles. Ce seul changement a accéléré à lui seul ma version de la fonction par un facteur de 3,59x.

Enfin, la récursivité est plus lente, elle prend de la place dans la pile, utilise plus de mémoire et a une limite au nombre de fois qu'elle peut "se reproduire". Ou, dans ce cas, combien d'étapes de réduction il peut utiliser pour terminer la réduction complète. Déployer votre récursivité en boucles itératives le maintient au même endroit sur la pile et n'a aucune limite théorique sur le nombre d'étapes de réduction qu'il peut utiliser pour terminer. Ainsi, ces fonctions peuvent ici "réduire" presque n'importe quel entier de taille, uniquement limité par le temps d'exécution et la longueur d'un tableau.

Tout cela à l'esprit ...

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 fonction ci-dessus est extrêmement rapide. Il est environ 3,13 fois plus rapide que l'OP (sans .map(Number)et console.log) et environ 8,4 fois plus rapide que la réponse de customcommander . Gardez à l'esprit que la suppression console.logde l'OP l'empêche de produire un nombre à chaque étape de réduction. D'où la nécessité ici de pousser ces résultats dans un tableau.

PT

Pourquoi ne pas appeler console.countdans votre fonction?

Edit: Extrait à essayer dans votre navigateur:

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)

Je le fais fonctionner dans Chrome 79 et Firefox 72

Vous pouvez utiliser la fermeture pour cela.

Stockez simplement counterdans la fermeture de la fonction.

Voici un exemple:

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

Voici une version Python qui utilise une fonction wrapper pour simplifier le compteur, comme cela a été suggéré par la réponse de slebetman - j'écris ceci uniquement parce que l'idée centrale est très claire dans cette implémentation:

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)