Home / Questions / 293313
Accepted
RazerJs
Asked: 2020-09-13 01:45:48 +0800 CST 2020-09-13 01:45:48 +0800 CST

Multiplication of numbers of an array, n times

  • 772

I want to make a function that multiplies the digits of a number until they give a result less than 10 and returns the number of multiplications of the digits of the number passed by parameter that were made...

Ex: function(234) = 2 // because 2*3*4 = 24, 2*4 = 8

Ex: function(49) = 3 // because 4*9 = 36, 3*6 = 18, 1*8=8

function multiplicacionPersistente(num) {
    
    let multiplicacion = String(num).split('').map(numeros => (
        Number(numeros)
    )).reduce((anterior,actual) =>(
        anterior*actual
    ));
    

    return multiplicacion 
}


var respuesta = multiplicacionPersistente(999)
console.log(respuesta);

It would be something like doing this function of mine but many times... recursive... thanks

javascript

4 Answers

  1. Best Answer

    You have the base case: the number is less than 10 (one digit):

    function multiplicaciones(n) {
  if (n<10) { return 0; }
  ...
}

    The case to iterate over would be when n > 10:

    ...
else {
    return 1 + multiplicaciones(String(n).split('').map(s => +s).reduce((acc,n)=> n*acc));
  }
  ...
}

    all this gives:

    function multiplicaciones(n) {
  if (n<10) {
  console.log('no hay que multiplicar', n);
    return 0; 
  } else {
    console.log('Multiplicando los dígitos de',n);
    return 1 + multiplicaciones(String(n).split('').map(s => +s).reduce((acc,n)=> n*acc));
  }
}

console.log('Numero de multiplicaciones para 99:',multiplicaciones(99));
console.log('Numero de multiplicaciones para 555:',multiplicaciones(555));

    • 6

  2. A solution without using recursion could be the following:

    • We create a variable to carry the number of times it is multiplied ( let counter = 0).

    • As long as the number is greater than or equal to 10:

      • We convert the number to a string ( eg: ''+num ==> string)
      • We get the numbers that compose it ( eg: string.split('') ==> array)
      • We multiply all the numbers together ( eg: array.reduce((acc, n) => acc * n) ==> number)
      • We increment the variable ( eg: counter++).

    Example:

    function multiplicacionPersistente(num) {
  let counter = 0;
  while (num >= 10) {
    num = ('' + num).split('').reduce((acc, n) => acc * n);
    counter++;
  }
  return counter;
}

console.log('Cantidad de multiplicaciones:', multiplicacionPersistente(999));

    • 4

  3. A simple way to make your function recursive would be like this:

    
function multiplicacionPersistente(num) {

    let multiplicacion = String(num).split('').map(numeros => (
        Number(numeros)
    )).reduce((anterior,actual) =>(
        anterior*actual
    ));
    if(multiplicacion < 10)
     multiplicacionPersistente(multiplicacion)
    return multiplicacion 
}
    • 2

  4. Well, believe it or not, there is an even simpler method with fewer lines, using a for:

      function multiplicacionPersistente (numero) {
    for (cont = 0; numero>10; cont++)
      numero=String(numero).split('').reduce((a,n)=> a*n);
    return cont;
  }
  
  console.log(multiplicacionPersistente(999));
  console.log(multiplicacionPersistente(234));
  console.log(multiplicacionPersistente(49));

    This is the most optimal way possible, greetings.

    • 2