Résumé en français : Ecrire une fonction qui admet en paramètre un nombre entier positif et qui retourne le nombre de fois où vous devez multiplier ses chiffres pour obtenir un seul chiffre.
On doit compter (variable compteur
) combien de fois il faut multiplier les chiffres entre eux jusqu'à obtenir un seul chiffre. Ce nombre d'itérations étant inconnu, nous allons naturellement utiliser une boucle Tant Que (while
). Maintenant, comment faire la multiplication des chiffres d'un nombre ? On peut par exemple transformer ce nombre en chaine puis en liste et multiplier les éléments de cette liste grâce à une boucle.
var mul = n =>
{
liste = [...''+n] ; // Conversion nombre > chaine > liste
produit = 1 ;
for (c of liste) produit *= +c ;
return produit
}
mul(999)
729
Ce qui donne ce programme pour la version classique :
var persistence = n =>
{
var compteur = 0; // Notre compteur de tours
while (n > 9) {
compteur ++;
produit = 1; // Calcul du produit des chiffres
liste = [...''+n]; // Conversion du nombre en liste
for (c of liste) produit *= +c; // +c --> entier
n = produit
}
return compteur;
}
persistence(999)
4
Si un nombre est plus petit que 10, sa persistence est 0. Sinon, sa persistence est 1 + la persistence du produit de ses chiffres. Par exemple :
persistence(39) = 1 + persistence(3 * 9) = 1 + persistence(27) = 1 + (1 + persistence(2 * 7)) = 1 + 1 + persistence(14) = 1 + 1 + (1 + persistence(1 * 4)) = 1 + 1 + 1 + persistence(4) = 1 + 1 + 1 + 0 = 3
Programme final version récursive :
var persistence = n => {
if (n < 10) return 0;
produit = 1;
liste = [...''+n];
for (c of liste) produit *= +c;
return 1 + persistence(produit)
}
persistence(999)
4
La multiplication des chiffres peut se faire par reduce
plutôt que par une boucle for
classique :
[...'999'].reduce((a,c) => a * (+c), 1) // avec parenthèses
729
[...'999'].reduce((a,c) => a * +c, 1) // ou sans parenthèse !
729
[...'999'].reduce((a,c) => a * +c) // ou sans initialisation !!
729
On obtient finalement :
var persistence = num =>
num < 10 ?
0 :
1 + persistence([...'' + num].reduce((a, c) => a * +c))
persistence(999)
4