JavaScript Multiplicative Persistence Problem Resolved by Implementing Efficient Solution that Executes in a Timely

Question

JavaScript Multiplicative Persistence Problem Resolved by Implementing Efficient Solution that Executes in a Timely

I am currently facing an issue with the following problem:

Your task is to create a function called persistence, which takes a positive parameter num and calculates its multiplicative persistence. Multiplicative persistence refers to the number of times you need to multiply the digits in num until you end up with a single digit.

function persistence(num) {

  let count = 0; 
  let numStr = num.toString(); 

   if (numStr.length === 1){
     return 0
   } 

   if (numStr.length === 2){
     while (numStr.length > 1){
       count += 1
       numStr = (Number(numStr[0])*Number(numStr[1])).toString() 
     }
   }

   if (numStr.length === 3){
     while (numStr.length > 1){
       count += 1
       numStr = (Number(numStr[0])*Number(numStr[1])*Number(numStr[2])).toString() 
     }
   }

   return count 
}

persistence(999) //solution 4

I am facing an issue where I keep getting an "Execution Timed Out (12000 ms)" error. While I understand that there are various approaches to solving this problem, I am particularly interested in understanding what might be incorrect with my code.

javascript function loops if-statement while-loop

Answer 1

Answer №1

The reason why your code is not functioning correctly is due to the continuous addition of str[2] to the final result.

999 > 729 > 126 > 12 > 2

During one loop, you can see that the number becomes 12, causing str[2] to be undefined. As a result, it will lead to NaN, preventing the loop from ending.

A more efficient approach is to use reduce() within a while loop without converting the numbers to Number() while performing multiplication.

function persistence(num) {

  let count = 0; 
  num = String(num);
  while(num.length > 1){
    count++;
    num = String([...num].reduce((ac,a) => a * ac,1));
  }
  return count;
}

console.log(persistence(999))

Answer 2

The reason why your code is not functioning correctly is due to the continuous addition of str[2] to the final result.

999 > 729 > 126 > 12 > 2

During one loop, you can see that the number becomes 12, causing str[2] to be undefined. As a result, it will lead to NaN, preventing the loop from ending.

A more efficient approach is to use reduce() within a while loop without converting the numbers to Number() while performing multiplication.

function persistence(num) {

  let count = 0; 
  num = String(num);
  while(num.length > 1){
    count++;
    num = String([...num].reduce((ac,a) => a * ac,1));
  }
  return count;
}

console.log(persistence(999))

Answer 3

Answer №2

If you want to achieve this task effortlessly, you can utilize a recursive function:

Simply introduce a new parameter called count (indicating how many times the function has been invoked) and execute the function recursively until the resulting length is greater than 1.

function calculatePersistence(num, count) {
  count = count || 0; 
  let numStr = num.toString(); 
  
  if (numStr.length === 1) {
    return count;
  } 
  let newNum = numStr.split('').reduce((acc, val) => {
    return acc * val;
  }, 1);
  return calculatePersistence(newNum, count + 1);
}

console.log("99", calculatePersistence(99));
console.log("999", calculatePersistence(999));
console.log("99999", calculatePersistence(99999));

Answer 4

If you want to achieve this task effortlessly, you can utilize a recursive function:

Simply introduce a new parameter called count (indicating how many times the function has been invoked) and execute the function recursively until the resulting length is greater than 1.

function calculatePersistence(num, count) {
  count = count || 0; 
  let numStr = num.toString(); 
  
  if (numStr.length === 1) {
    return count;
  } 
  let newNum = numStr.split('').reduce((acc, val) => {
    return acc * val;
  }, 1);
  return calculatePersistence(newNum, count + 1);
}

console.log("99", calculatePersistence(99));
console.log("999", calculatePersistence(999));
console.log("99999", calculatePersistence(99999));

JavaScript Multiplicative Persistence Problem Resolved by Implementing Efficient Solution that Executes in a Timely

Answer №1

Answer №2

Similar questions

Ways to eliminate double slashes from URL in Next Js. Techniques for intercepting and editing a request on the server side using getServerSideProps

converting code from JavaScript to Flask and then back to JavaScript, all within a single-page application

Swapping JSON: A Quick Guide

Rotation to a point in a circle using three.js

JavaScript's Blob to Base64 conversion using FileReader is failing to produce any output

Can the outcomes be showcased again upon revisiting a page?

Pressing the enter key does not submit the Vue.js form

Embed a React component seamlessly within HTML code

What is the significance of the statement "What is the meaning of "#include <common>" in Three.js, WebGL, and GLSL?

jQuery can be used to mask phone numbers with three input fields

Is a function repeatedly invoked?

Numerous checkboxes have been chosen alongside a submission button

What is the method for defining distinct parameters for nested functions in AngularJS?

The output of VueJs hooks shows a blank refs object first, followed by the referenced elements

Is there a way to delete a stylesheet if I only have limited information about the url?

Using an Ajax request to fetch and display warning information

Utilizing Twitter API authentication to prevent hitting rate limits

Utilize a singular ajax function to handle various events with personalized data parameters

Unable to resolve issue with Display:flex in my CSS, despite numerous attempts

Learning how to effectively incorporate two matSuffix mat-icons into an input field