TI-BASIC (TI-84), 30 32 bytes

While Ans>9:Disp Ans:prod(int(10fPart(Ansseq(10^(-X-1),X,0,log(Ans:End:Ans

Input is in Ans.

Output is displayed as the challenge requests. The trailing Ans is needed to print the last step.

I will admit, I did not think of this formula myself, rather I found it here and modified it to better fit the challenge.

EDIT: Upon rereading the challenge, I realized that the program must terminate if the product is one digit. Hence, 2 bytes were to be added to account for this.

Example:

24456756

        24456756

prgmCDGF8

        24456756

          201600

               0

11112

           11112

prgmCDGF8

           11112

               2

Explanation:

While Ans>9:Disp Ans:prod(int(10fPart(Ansseq(10^(-X-1),X,0,log(Ans:End:Ans  ;full program



While Ans>9                                                        End      ;loop until the product is one digit

            Disp Ans                                                        ;print the current number

                     prod(                                                  ;get the product of

                                         seq(                                 ;the list generated by

                                             10^(-X-1),                         ;consecutive powers of ten

                                                       X,                       ;using X as the increment variable

                                                         0,                     ;starting at 0

                                                           log(Ans              ;ending at the length of the current number

                                                                              ;(implicit increment by 1)

                                      Ans                                     ;multiplied by the current number

                                fPart(                                        ;then taking the fractional part of each element

                              10                                              ;multiplied by 10

                          int(                                                ;then truncating each element

                                                                       Ans  ;output last step since it was skipped

Visual Model:
Ans starts off as 125673.

This model only covers the logic behind multiplying the digits; everything else is easier to understand.

seq(10^(-X-1),X,0,log(Ans  =>  seq(10^(-X-1),X,0,5.0992

   {.1 .01 .001 1E-4 1E-5 1E-6}

Ans...

   {12567.3 1256.73 125.673 12.5673 1.25673 .125673}

fPart(...

   {.3 .73 .673 .5673 .25673 .125673}

10...

   {3 7.3 6.73 5.673 2.5673 1.25673}

int(...

   {3 7 6 5 2 1}

   (the digits of the number, reversed)

prod(...

   1260

   (process is repeated again)



seq(10^(-X-1),X,0,log(Ans  =>  seq(10^(-X-1),X,0,3.1004

   {.1 .01 .001 1E-4}

Ans...

   {126 12.6 1.26 .126}

fPart(...

   {0 .6 .26 .126}

10...

   {0 6 2.6 1.26}

int(...

   {0 6 2 1}

prod(...

   0

   (product is less than 10.  loop ends)

Notes:

TI-BASIC is a tokenized language. Character count does not equal byte count.

10^( is this one-byte token.

This program will not provide the correct sequence of products with integers greater than 14 digits long due to the limitations of decimal precision on the TI calculators.

K (ngn/k), 9 bytes

{*/.'$x}

Try it online!

{ } keep applying the function in curly braces until the sequence converges

$x format the argument as a string (list of characters)

.' evaluate each (other dialects of k require a colon, .:')

*/ times over, i.e. product

dzaima/APL, 14 11 bytes

∪{×/⍎¨⍕⍵}⍡≡

Try it online!

R, 59 bytes

n=scan();while(print(n)>9)n=prod(n%/%10^(nchar(n):1-1)%%10)

Try it online!

Since print invisibly returns its input, we can use print(n) inside the while loop to simulate a do-while loop. This is inspired by one of my tips for golfing in R.

The header helps prevent large numbers from being printed in scientific notation.

05AB1E, 7 4 bytes

Δ=SP

Try it online or verify all test cases.

Explanation:

Δ     # Loop until the number no longer changes:

 =    #  Print the number with trailing newline (without popping the number itself)

      #  (which will be the implicit input in the first iteration)

  SP  #  Convert the number to a list of digits, and calculate its product

Perl 6, 23 bytes

{$_,{[*] .comb}…10>*}

Try it online!

Python 2,  46  43 bytes

-3 thanks to xnor (chained comparison)

def f(n):print n;n>9>f(eval('*'.join(`n`)))

Try it online!

Wolfram Language (Mathematica), 47 bytes

Most@FixedPointList[Times@@IntegerDigits@#&,#]&

Try it online!

Wolfram Language (Mathematica), 45 bytes

#//.x_/;x>9:>Times@@IntegerDigits@x&&Print@x&

Try it online!

Jelly, 4 bytes

DP$Ƭ

Try it online!

Explanation

D    | convert to decimal digits

 P   | take the product

  $  | previous two links as a monad

   Ƭ | loop until no change, collecting all intermediate results

As a bonus, here's a TIO which will find the numbers with the largest number of steps for a given range of numbers of digits. It scales well even on TIO.

Julia 0.7, 36 bytes

f(n)=n>9?[n,f(prod(digits(n)))...]:n

Try it online!

PowerShell, 54 bytes

for($a=$args;$a-gt9){$a;$a=("$a"|% t*y)-join"*"|iex}$a

Try it online!

Iterative method that first writes the input argument, then converts it into a string and pipes it into a character array. This array is joined by a single asterisks, and executed as a command with the invoke expression alias. Since this writes Starting number down to the last number greater than 0, (20, in the given test scenario), I add a final $a to the end to output.

C# (Visual C# Interactive Compiler), 79 74 68 bytes

void f(int a){Print(a);if(a>9)f((a+"").Aggregate(1,(j,k)=>k%48*j));}

I try to stay away from recursion in C# due to how long the method declaration is, but in this case it saves compared to a loop.

Try it online!

Python 2, 61 62 59 bytes

def f(n):print n;n>9and f(reduce(int.__mul__,map(int,`n`)))

Try it online!

_{-3 bytes, thanks to Jonathan Allan}

perl 5 (-n -M5.01), 32 30 25 bytes

say$_=eval;s/B/*/g&&redo

25 bytes

30 bytes

32 bytes

MathGolf, 9 10 bytes

h(ôo▒ε*h(→

Try it online!

Now it correctly handles inputs that are single digits. Not perfect, but at least it is correct.

Explanation

h(            check length of input number and decrease by 1

  ö       →   while true with pop using the next 6 operators

   p          print with newline

    ▒         split to list of chars/digits

     ε*       reduce list by multiplication

       h(     length of TOS without popping, subtracted by 1 (exits when len(TOS) == 1)

JavaScript (ES6), 45 bytes

Returns an array of integers.

f=n=>[n,...n>9?f(eval([...n+''].join`*`)):]

Try it online!

PowerShell, 51 bytes

filter f{$_

if($_-gt9){("$_"|% t*y)-join'*'|iex|f}}

Try it online!

Haskell, 45 bytes

f n=n:[x|n>9,x<-f$product$read.pure<$>show n]

Try it online!

PHP, 63 bytes

<?=$n=$argn;while($n>9)echo"

",$n=array_product(str_split($n));

Iterative version, call with php -nF input from STDIN.

Try it online!

PHP, 72 71 bytes

function h($n){echo"$n

",($n=array_product(str_split($n)))>9?h($n):$n;}

Try it online!

Recursive version, as function.

Input: 277777788888899

277777788888899

4996238671872

438939648

4478976

338688

27648

2688

768

336

54

20

0

Input: 23

23

6

J, 16 bytes

([:*/,.&.":)^:a:

Try it online!

Ruby, 38 35 34 bytes

f=->n{p(n)>9&&f[eval n.digits*?*]}

Try it online!

1 byte saved by by G B.

Brachylog, 7 bytes

ẉ?Ḋ|ẹ×↰

Try it online!

Explanation

ẉ          Write the input followed by a linebreak

 ?Ḋ        If the input is a single digit, then it's over

   |       Otherwise

    ẹ      Split the input into a list of digits

     ×     Multiply them together

      ↰    Recursive call with the result of the multiplication as input

JavaScript (Babel Node), 46 bytes

f=a=>a>9?[a,...f(eval([...a+''].join`*`))]:[a]

Try it online!

JavaScript (Babel Node), 44 bytes

If the input can be taken as String

f=a=>a>9?[a,...f(''+eval([...a].join`*`))]:a

Try it online!

PowerShell, 64 59 bytes

for($a="$args";9-lt$a){$a;$a="$(($a|% t*y)-join'*'|iex)"}$a

Try it online!

Iterative method. Takes input and stores it into $a, then enters a for loop so long as the length of $a is two or more (i.e., it's bigger than 9). Inside the loop we output $a and then recalculate it by converting it toCharArray, joining it together with *, and then iex (short for Invoke-Expression and similar to eval). Once we're out of the loop, we have a single digit left to print, so we place $a onto the pipeline again.

-5 bytes thanks to KGlasier.

APL(NARS), 19 chars, 38 bytes

{⍵≤9:⍵⋄∇×/⍎¨⍕⍵⊣⎕←⍵}

test:

   f←{⍵≤9:⍵⋄∇×/⍎¨⍕⍵⊣⎕←⍵}

   f 23     

23

6

   f 27648     

27648

2688

768

336

54

20

0

Charcoal, 13 bytes

θＷ⊖Ｌθ«≔ＩΠθθ⸿θ

Try it online! Link is to verbose version of code. Explanation:

θ

Print the input for the first time.

Ｗ⊖Ｌθ«

Repeat while the length of the input is not 1.

≔ＩΠθθ

Replace the input with its digital product cast to string.

⸿θ

Print the input on a new line.

C (gcc), 58 bytes

f(n,t){for(;n=printf("%dn",t=n)>2;)for(;n*=t%10,t/=10;);}

Try it online!

Iterative approach turns out to be 1 byte shorter.

f(n,t){

    for(;n=printf("%dn",t=n)   //print and update current number

            >2;)                //until only one digit is printed

        for(;n*=t%10,t/=10;);   //n*= product of digits of t (step)

}

C (gcc), 61 59 bytes (recursive)

f(n){printf("%dn",n)>2&&f(p(n));}p(n){n=n?n%10*p(n/10):1;}

Try it online!

Recursion seems to be shorter than iteration for both print and step...

Retina, 24 bytes

.+~(`



.

$&$*

^

.+¶$$.(

Try it online! Explanation:

.+~(`

Print the current value on its own line at the start of every loop until it stops changing and don't print the unchanged value twice. Evaluate the current value at the end of each loop.

.

$&$*

Add a * after each digit.

^

.+¶$$.(

Finish turning the input into an expression that evaluates to the digital product.

Just for the record, Retina can do this in one line (25 bytes):

.+"¶"<~[".+¶$.("|'*]'*L`.

Java, 112 bytes

"Lossy conversion" thanks Java for the extra ~15 bytes


Obligatory stream abuse recursion answer

long f(long n){System.out.println(n);return n<10?n:f((n+"").chars().mapToLong(i->i).reduce(1,(x,y)->x*(y-48)));}

Try it online