Computing persistence number of an integer

Question

I am trying to make a code that does the following:

Multiplying the digits of an integer and continuing the process gives the surprising result that the

Answer 1

Functions are friends.

Consider a function, getEnds(x), which when passed an integer, x will extract the first digit and the last digit (as integers) and return the result as a tuple in the form (first_digit, last_digit). If x is a single-digit number the tuple will contain one element and be in the form (x), otherwise it will be two. (A simple way to do this is to turn the number into a string, extract the first/last digit as a string, and then convert said strings back into numbers... however, there are many ways: just make sure to honor the function contract, as stated above and -- hopefully -- in the function documentation.)

Then, where n is the current number we are finding the persistence for:

ends = getEnds(n)
while ends contains two elements
   n = first element of ends times second element of ends
   ends = getEnds(n)
# while terminates when ends contained only one element
# now it's only a matter of "counting" the persistence

For added points, make sure this is in a -- [an] appropriately named/documented -- function as well and consider the use of a recursive function instead of a while-loop.

Happy coding.

Answer 2

If you're trying to get the digits of a number, convert it into a string first and reference them with array notation.

Answer 3

You should use a while or for loop to multiply the digits instead of hardcoding what to do with the first, second and so on digits.

In pseudocode...

productSoFar = 1
digitsLeftToMultipy = #the number
while there are digits left to multiply:
    get the next digit and
    update produtsSoFar and digitsLeftToMultiply

Also, use

10 <= n < 100

instead of

n in range(10, 100)

So you only do a couple of comparisons instead of a sequential lookup that takes time proportional to the length of the range.