Как работать с числами, которые нужно разбить на отдельные части?

Question

Итак, я сейчас нахожусь на подготовительном курсе, и многие возможные проблемы с leetcode, которые могут возникнуть во время экзамена, связаны с такими вещами, как факториалы и числа.

Например, это одна из проблемы

Напишите функцию, постоянство, которая принимает положительный параметр num и возвращает его мультипликативную стойкость, то есть количество раз, которое вы должны умножить цифры в num, пока не достигнете единственного di git. Например:

 persistence(39) === 3 // because 3*9 = 27, 2*7 = 14, 1*4=4
                       // and 4 has only one digit

 persistence(999) === 4 // because 9*9*9 = 729, 7*2*9 = 126,
                        // 1*2*6 = 12, and finally 1*2 = 2

 persistence(4) === 0 // because 4 is already a one-digit number

Теперь мой вопрос: я знаю, что мы можем использовать что-то вроде этого

var arr = num.toString().split('');

И это даст нам arr строк, и мы можем просто вызовите что-то подобное в l oop

for (var i = 0; i < arr.length; i++) { 
  var currentNum = Number(arr[i]);
}

Но я изо всех сил пытаюсь понять, как я могу реализовать, может быть, некоторое время l oop или какое-то условие, чтобы продолжить l oop через проблема.

Например, в этом случае 39 станет

39-> 3*9 | (27) 27-> 2*7 | (14) 14-> 1*4

Однако я изо всех сил пытаюсь понять, как на самом деле делать непрерывный l oop. Например, если это где-то просто сделать один l oop Я могу это сделать, но я потерялся в рекурсии.

Если бы кто-нибудь мог провести меня через это с некоторым уровнем детализации, это было бы действительно полезно, спасибо!

Answer 1

Вот быстрое решение. Надеюсь, это поможет!

function p(num){
  var new_num = 1,
      sNumber = num.toString(),
      len = sNumber.length,
      counter = 0;

  while(len > 1) {
    counter = counter + 1;
    for (var i = 0; i < len; i += 1) {
      new_num = new_num * parseInt(sNumber.charAt(i));
    }
    sNumber = new_num.toString();
    len = sNumber.length;
    new_num=1;
  }
  return counter;
 }
console.log(p(39));
console.log(p(999));
console.log(p(4));

Answer 2

Если вас интересует рекурсивная версия:

function p(input){
const v = input.toString();
if(v.length<=1){
   return 0;
}

let product = 1;
for(var i=0;i< v.length;i++)
{
   product *= parseInt(v[i]);
}

   return p(product)+1;
}

console.log(p(999));
console.log(p(39));
console.log(p(4));

Answer 3

Похоже, вы на правильном пути с while l oop, так что это то, что я использовал. Я добавлю больше комментариев к этому коду в разделе «правки» после публикации.

function p(n) {

    // n = n.toString();
    // v = n;

    var cnt = 0;

    var v = n.toString();
    
    while (v.length > 1) {
        var digits = v.split('');
        
        var product = 1;
        
        for (var i = 0; i < digits.length; i++) {
            product *= parseInt( digits[i] );
        }
        
        v = product.toString();

        cnt++;
        
    }
    
    // This line returns the final value, not the "count" or "persistence"
    // return parseInt(v);

    // This line (edit) returns the "persistence"
    return cnt;
    
}

console.log( p(999) );
console.log( p(39) );
console.log( p(4) );

В основном то, что здесь работает, - это n преобразование в строку в случае, если оно прибыло как число. Затем while l oop продолжается до тех пор, пока v length больше единицы, поэтому на самом деле вы можете просто установить v = n.toString() там, такая же разница.

Теперь, если длина v больше 1 чем аналогично, v не меньше 10. Таким образом, l oop продолжается до тех пор, пока это не произойдет с остальной частью logi c внутри l oop.

v - это строка, поэтому разделить на цифры, как вы предложили в своем вопросе.

product начинается как 1, а не 0 по очевидным причинам. Цифры умножаются вместе с помощью for l oop.

Затем этот продукт становится новым v, так что l oop может либо повторяться снова, либо завершаться на основе условия while.

Answer 4

Держу пари, что некоторые вещи могут показаться вам необычными, но, как товарищу javascript пользователю, вам нужно научиться находить прямые решения

function persistence(num){
  var numArr = num.toString().split``; //only these quotes skip out the brackets for functions. eg: functionName('abc'+varName) is the same as functionName`abc${varName}`
  var ans = 0;
  while(numArr.length > 1){
    var newNum = 1;
    numArr.forEach((a,i)=>{newNum *= a}); //this is basically a for loop structure for arraays. a is the element, i is the index. "1" is the same as 1 when it comes to multiplication, division and subtraction (NOT ADDITION)
    numArr = newNum.toString().split``;
    ans++;
  }
  return(ans);
}
//solution examples
console.log(persistence(999));
console.log(persistence(81));
console.log(persistence(4));
console.log(persistence(39));
//yes, it looks simple and straightfoward... ur welcome

Answer 5

Вы можете создать функцию, которая будет выполнять умножение, а затем вызывать ее каждый раз, когда число больше 10

function getper(n){
  var arr = n.toString().split('');
  i=1
  res= multi(arr)
  do{
   if(res>10) {
    na= res.toString().split('')
    res=multi(na)
    if(res<10){
       i=-1
    }
    else i++
   }
      else i=-1

  }while(i>0)
  return res
}
console.log(getper(39))
console.log(getper(999));
console.log(getper(4));
function multi(arr){
 return arr.reduce((acc,curr)=>{
    return acc*curr
  })
}