[Question]
  [
## Multiplicative Persistence
1. Multiply all the digits in a number
2. Repeat until you have a single digit left
As explained by *Numberphile*:
* [*Numberphile* "What's special about 277777788888899?"](https://www.youtube.com/watch?v=Wim9WJeDTHQ)
* [*Numberphile* "Multiplicative Persistence (extra footage)"](https://www.youtube.com/watch?v=E4mrC39sEOQ)
### Example
1. 277777788888899 → 2x7x7x7x7x7x7x8x8x8x8x8x8x9x9 = 4996238671872
2. 4996238671872 → 4x9x9x6x2x3x8x6x7x1x8x7x2 = 438939648
3. 438939648 → 4x3x8x9x3x9x6x4x8 = 4478976
4. 4478976 → 4x4x7x8x9x7x6 = 338688
5. 338688 → 3x3x8x6x8x8 = 27648
6. 27648 → 2x7x6x4x8 = 2688
7. 2688 → 2x6x8x8 = 768
8. 768 → 7x6x8 = 336
9. 336 → 3x3x6 = 54
10. 54 → 5x4 = 20
11. 20 → 2x0 = 0
This is the current record, by the way: the smallest number with the largest number of steps.
## Golf
A program that takes any whole number as input and then outputs the result of each step, starting with the input itself, until we hit a single digit. For 277777788888899 the output should be
```
277777788888899
4996238671872
438939648
4478976
338688
27648
2688
768
336
54
20
0
```
(Counting the number of steps is left as an exercise to the user).
### More Examples
From [A003001](https://oeis.org/A003001):
```
25
10
0
```
From A003001 as well:
```
68889
27648
2688
768
336
54
20
0
```
From the *Numberphile* video, showing that the single digit doesn't have to be 0:
```
327
42
8
```
---
*So there has been [a question about Additive Persistence](https://codegolf.stackexchange.com/q/1775/14150), but this is Multiplicative Persistence. Also, that question asks for the number of steps as output, while I'm interested in seeing the intermediate results.*
  
[Answer]
# TI-BASIC (TI-84), ~~30~~ ~~32~~ 31 bytes
*-1 byte thanks to @SolomonUcko!*
```
While Ans>9:Disp Ans:prod(int(10fPart(Ans10^(seq(-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](http://tibasicdev.wikidot.com/sum-of-digits) 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               ;loop until the product is one digit
Disp Ans                  ;display the current product
prod(                     ;get the product of...
 int(                     ; the integer part of...
  10fPart(                ; ten times the fractional part of...
  Ans                     ; each element in the following list times the
                          ;  current product
  10^(                    ; multiplied by the list generated by using each
                          ;  element of the following list as an exponent
                          ;  for 10^n
   seq(-X-1),X,0,log(Ans  ; generate a list of exponents from -1 to -L where
                          ;  L = the length of the current product
End
Ans                       ;leave the final product in "Ans" and implicitly
                          ; print it
```
**Visual Model:**  
`Ans` starts off as `125673`.  
This model only covers the logic behind multiplying the digits; everything else is easier to understand.
```
seq(-X-1,X,0,log(Ans  =>  seq(-X-1,X,0,5.0992
   {-1 -2 -3 -4 -5 -6}
10^(...
   {.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(-X-1,X,0,log(Ans  =>  seq(-X-1,X,0,3.1004
   {-1 -2 -3 -4}
10^(...
   {.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](http://tibasicdev.wikidot.com/ten-exponent).
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.
[Answer]
# [K (ngn/k)](https://gitlab.com/n9n/k), 9 bytes
```
{*/.'$x}\
```
[Try it online!](https://tio.run/##y9bNS8/7/z/NqlpLX09dpaI25n@agpE5GFiAgaXlfwA "K (ngn/k) – 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
[Answer]
# [R](https://www.r-project.org/), ~~59~~ 57 bytes
```
n=scan();while(print(n)>9)n=prod(n%/%10^(0:log10(n))%%10)
```
[Try it online!](https://tio.run/##DcnBCoAgDADQrxG2U2p0qLBPCcKkBrKJCn3@8vpeVSmdhBu0SCVx8DMqhxYvBty/l3KCUok7MB4rcihVbmAzGWdPsFuWx9lxaAag@kV/ "R – 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](https://codegolf.stackexchange.com/a/157131/67312).
The header helps prevent large numbers from being printed in scientific notation.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 4 bytes
```
DP$Ƭ
```
[Try it online!](https://tio.run/##y0rNyan8/98lQOXYmv///xuZg4EFGFhaAgA "Jelly – 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](https://tio.run/##AT8AwP9qZWxsef//RFAkxqxM4oCZ/3LFk8SLQDIsMyw0LDYsNyw4LDnhuIxGw4c7JOKCrDHhu4skw5DhuYD//zH/MTU) 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. 
[Answer]
# [dzaima/APL](https://github.com/dzaima/APL), ~~14~~ 11 bytes
```
∪{×/⍎¨⍕⍵}⍡≡
```
[Try it online!](https://tio.run/##SyzI0U2pSszMTfyf9qhtgsb/Rx2rqg9P13/U23doxaPeqY96t9Y@6l34qHPhf02uR31TgWrSFEzhLHNzczjbyBwMLMDA0vI/AA "APL (dzaima/APL) – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~7~~ 4 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
Δ=SP
```
[Try it online](https://tio.run/##yy9OTMpM/f//3BTb4ID//43MwcACDCwtAQ) or [verify all test cases](https://tio.run/##yy9OTMpM/V9W@f/cFNvggP@1h7bZ/482MgcDCzCwtNQxMtUxA7F0jI3MYwE).
**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
```
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 47 bytes
```
Most@FixedPointList[Times@@IntegerDigits@#&,#]&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n2773ze/uMTBLbMiNSUgPzOvxCezuCQ6JDM3tdjBwTOvJDU9tcglMz2zpNhBWU1HOVbtf0ARUJWCvoNCerSRORhYgIGlZez//wA "Wolfram Language (Mathematica) – Try It Online")
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 23 bytes
```
{$_,{[*] .comb}…10>*}
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJZm@79aJV6nOlorVkEvOT83qfZRwzJDAzut2v/WCsWJlQppGkbmYGABBpaWmv8B "Perl 6 – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), ~~46~~ 43 bytes
-3 thanks to xnor (chained comparison)
```
def f(n):print n;n>9>f(eval('*'.join(`n`)))
```
**[Try it online!](https://tio.run/##XY3BCsIwEETP7VcsvWQjQWwq6Ebot1QwwYhsQk0Fvz6mET048HZgBnbiK10D65wv1oFDlibOnhPwiUcaHdrn@Y5iI7a34BknnqSU2YUZkn0k8AyoD1XHKiIF/a7QF3RhWL0cPewVEJE0bfNZ6DzHJZlO1Ve/NCypxtA2DtdGfish8t/WGw "Python 2 – Try It Online")**
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 39 bytes
```
0Print@#+#>9&&#0@@Times@@@RealDigits@#&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n2773yCgKDOvxEFZW9nOUk1N2cDBISQzN7XYwcEhKDUxxyUzPbOk2EFZ7X96tJE5GFiAgaVl7P//AA "Wolfram Language (Mathematica) – Try It Online")
-6 bytes from @att
[Answer]
# [Julia 0.7](http://julialang.org/), ~~36~~ 33 bytes
```
f(n)=n>9?[n;f(prod(digits(n)))]:n
```
[Try it online!](https://tio.run/##yyrNyUw0//8/TSNP0zbPztI@Os86TaOgKD9FIyUzPbOkGCiuqRlrlfc/N7FAI1PXrqAoM68kJ08jU1MnTcPIHAwswMDSUlPzPwA "Julia 0.7 – Try It Online")
Thanks to H.PWiz for -3 bytes.
[Answer]
# [V (vim)](https://github.com/DJMcMayhem/V), 29 bytes
```
qqlYp:s/./&*/g
C<C-r>=<C-r>"<BS>
<esc>|@qq@q
```
[Try it online!](https://tio.run/##K/v/v7AwJ7LAqlhfT19NSz@dy1nIVkiJg0u6xqGw0KHw/38jczCwAANLSwA "V (vim) – Try It Online")
[Answer]
# JavaScript (ES6), 45 bytes
Returns an array of integers.
```
f=n=>[n,...n>9?f(eval([...n+''].join`*`)):[]]
```
[Try it online!](https://tio.run/##VchNCoAgEEDhfRfJ6WcWbcwgO4gISWkUMhMVXd@oXd/uvc3d7pyOdb9q4tmnFHrqtaEKEUmrIQh/uyjMm2WeW9x4pbEYATpjbZqYTo4eIy8iCCklQPZ/jfy0H6UA0gM "JavaScript (Node.js) – Try It Online")
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 54 bytes
```
for($a=$args;$a-gt9){$a;$a=("$a"|% t*y)-join"*"|iex}$a
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/Py2/SEMl0VYlsSi92FolUTe9xFKzWiURyLTVUFJJVKpRVSjRqtTUzcrPzFPSUqrJTK2oVUn8//@/kTkYWICBpSUA "PowerShell – 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.
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 51 bytes
```
filter f{$_
if($_-gt9){("$_"|% t*y)-join'*'|iex|f}}
```
[Try it online!](https://tio.run/##XZDdasMwDIXv8xTGuDQuCtQ/seXBYG@Si83ZUkLapRnrSPLsmZwtZUwXx9KnI2R0OX/G/voW23ZZ6qYdYs/qUVRZU@eiKl6HIMeci4pPOzYcvmRxOjfd/rCfmnib6nlenvKMUUCu/Rq4RgjA/gMbgtMGnVfoNViDwQRnEaz1GLwDQz1E0D5BnVLvkKiD0oI@wlH@blJAj9oqbagkcfd2Iuov0cbSd0i0BdxgmeZIVAnlxrwnRmID0FqFyS3ZxHZsXB2iAybi7RKfh/jCHhndacV9vH60QwLdVK@IC7raD@ZFfOf3KS4fNj/P5uUb "PowerShell – Try It Online")
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), ~~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!](https://tio.run/##Sy7WTS7O/P@/LD8zRSFNIzOvRCFRszqgCMjQSNS0zkzTSLSz1EzT0EjUVlLS1HNMTy9KTU8sSdUw1NHI0snWtLXLVjWx0MrS1LSu/Q/WrxeQWFScqhGUmpjik5mXqqEJlPpvYmEEAA "C# (Visual C# Interactive Compiler) – Try It Online")
[Answer]
# [PHP](https://php.net/), 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!](https://tio.run/##K8go@G9jX5BRoKCSWJSep2CrkJaeWlKsERzi4umnaa1gbweUtlXJswVLW5dnZOakaqjk2VlqpiZn5CtxKekA5RKLihIr4wuK8lNKk0s0ikuK4osLcjJLgOo0Na3//zcyBwMLMLC0BAA "PHP – Try It Online")
# [PHP](https://php.net/), ~~72~~ 71 bytes
```
function h($n){echo"$n
",($n=array_product(str_split($n)))>9?h($n):$n;}
```
[Try it online!](https://tio.run/##K8go@G9jXwAk00rzkksy8/MUMjRU8jSrU5Mz8pVU8riUdIBc28SiosTK@IKi/JTS5BKN4pKi@OKCnMwSkEpNTTtLe7AeK5U869r/II1AMxTS0lNLijWCQ1w8/TQVNHUUAjwC4l39faz/G5mDgQUYWFoCAA "PHP – Try It Online")
Recursive version, as function.
Input: [277777788888899](https://tio.run/##K8go@G9jXwAk00rzkksy8/MUMjRU8jSrU5Mz8pVU8riUdIBc28SiosTK@IKi/JTS5BKN4pKi@OKCnMwSkEpNTTtLe7AeK5U869r/II1AMxTS0lNLijWCQ1w8/TQVNHUUAjwC4l39faz/G5mDgQUYWFoCAA "PHP – Try It Online")
```
277777788888899
4996238671872
438939648
4478976
338688
27648
2688
768
336
54
20
0
```
Input: [23](https://tio.run/##K8go@G9jXwAk00rzkksy8/MUMjRU8jSrU5Mz8lXydJS4lHSAfNvEoqLEyviCovyU0uQSjeKSovjigpzMEpBSTU07S3uwJiuVPOva/yCdQEMU0tJTS4o1gkNcPP00FTR1FAI8AuJd/X2s/xsZAwA)
```
23
6
```
[Answer]
# [J](http://jsoftware.com/), 16 bytes
```
([:*/,.&.":)^:a:
```
[Try it online!](https://tio.run/##y/qfVmyrp2CgYKVg8F8j2kpLX0dPTU/JSjPOKtHqvyaXkp6CepqtnrqCjkKtlUJaMRdXanJGvkKagpE5GFiAgaUl138A "J – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), ~~61~~ ~~62~~ 59 bytes
```
def f(n):print n;n>9and f(reduce(int.__mul__,map(int,`n`)))
```
[Try it online!](https://tio.run/##K6gsycjPM/r/PyU1TSFNI0/TqqAoM69EIc86z84yMS8FKFaUmlKanKoBFNWLj88tzYmP18lNLADxdRLyEjQ1Nf@naRiZg4EFGFhaanKBTeECShhr/gcA "Python 2 – Try It Online")
-3 bytes, thanks to Jonathan Allan
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~38~~ ~~35~~ 34 bytes
```
f=->n{p(n)>9&&f[eval n.digits*?*]}
```
[Try it online!](https://tio.run/##KypNqvz/P81W1y6vukAjT9POUk0tLTq1LDFHIU8vJTM9s6RYy14rtvZ/WrSRORhYgIGlZex/AA "Ruby – Try It Online")
1 byte saved by by G B.
[Answer]
# perl 5 (`-n` `-M5.01`), ~~32~~ ~~30~~ 25 bytes
```
say$_=eval;s/\B/*/g&&redo
```
[25 bytes](https://tio.run/##K0gtyjH9/784sVIl3ja1LDHHulg/xklfSz9dTa0oNSX//38jczCwAANLy3/5BSWZ@XnF/3Xz/uv6muoZGAIA)
[30 bytes](https://tio.run/##K0gtyjH9/784sVIl3ja1LDHHulhfw14xrkZFU19LP11NrSg1Jf//fyNzMLAAA0vLf/kFJZn5ecX/dfP@6/qa6hkYAgA)
[32 bytes](https://tio.run/##K0gtyjH9/784sdJaRclWXUvdWkMl3ja1LDFHycFNSdPOUk2tKDUl//9/I3MwsAADS8t/@QUlmfl5xf91cwrc9PX/6/qa6hkYAgA)
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf), ~~9~~ 10 bytes
```
h(ôo▒ε*h(→
```
[Try it online!](https://tio.run/##y00syUjPz0n7/z9D4/CW/EfTJp3bqpWh8aht0v//hlymXJZchsZchkbGJqZcRuZgYAEGlpb/AQ "MathGolf – 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)
```
[Answer]
# APL(NARS), 19 chars, 38 bytes
```
{⍵≤9:⍵⋄∇×/⍎¨⍕⍵⊣⎕←⍵}
```
test:
```
   f←{⍵≤9:⍵⋄∇×/⍎¨⍕⍵⊣⎕←⍵}
   f 23     
23
6
   f 27648     
27648
2688
768
336
54
20
0
```
[Answer]
## Haskell, 45 bytes
```
f n=n:[x|n>9,x<-f$product$read.pure<$>show n]
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P00hzzbPKrqiJs/OUqfCRjdNpaAoP6U0uUSlKDUxRa@gtCjVRsWuOCO/XCEv9n9uYmaegq1CQVFmXomCikKagpE5GFiAgaXlfwA "Haskell – Try It Online")
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-R`](https://codegolf.meta.stackexchange.com/a/14339/), 9 bytes
Horribly inefficient - don't even *try* to run the first test case!
```
_ì ×}hN â
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LVI=&code=X%2bwg131oTiDi&input=Nzc3)
```
_ì ×}hN â     :Implicit input of integer U
      N       :Starting with the array of inputs (i.e., [U])
     h        :Do the following U times, pushing the result to N each time
_             :Take the last element in N and pass it through the following function
 ì            :  Convert to digit array
   ×          :  Reduce by multiplication
    }         :End function
        â     :Deduplicate N
              :Implicitly join with newlines and output
```
[Answer]
# Chevron, 100 bytes
```
>^__>>^n
->+11?^n<10
>^n
^d<<1
^i<<1
^m<^i>^n
->+4??^m=^__
^d<<^d*^m
^i<<^i+1
->-4
^n<<^d
->-10
><^n
```
This is a fairly new language of my own creation - prototype interpreter, documentation, and example programs can be found at <https://github.com/superloach/chevron>.
## Explanation:
* `>^__>>^n` - take the input as a NUM, with empty prompt
* `->+11?^n<10` - if the number is under 10 (1 digit), skip to the end
* `>^n` - output the current number
* `^d<<1` - initialise the product to 1
* `^i<<1` - initialise the character index to 1
* `^m<^i>^n` - get i'th character of the number
* `->+4??^m=^__` - jump out of loop if no character is found
* `^d<<^d*^m` - multiply character into product
* `^i<<^i+1` - increment character index
* `->-4` - hop back to continue getting characters
* `^n<<^d` - once loop is done, assign product as new number
* `->-10` - hop all the way to the beginning for the next iteration
* `><^n` - exit, printing the final number
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 7 bytes
```
ẉ?Ḋ|ẹ×↰
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/r//@GuTvuHO7pqHu7aeXj6o7YN//8bmYOBBRhYWv4HAA "Brachylog – 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
```
[Answer]
# [JavaScript (Babel Node)](https://babeljs.io/), 46 bytes
```
f=a=>a>9?[a,...f(eval([...a+''].join`*`))]:[a]
```
[Try it online!](https://tio.run/##JcpLDkAwFAXQ5Wh93sBAkGAh1aQXrZCmTxDbL4nZGZwdD6753I67mDBZXwRebIyuQ9ejbwaFnIicsA@8UB@RJYmmnbdgUiOlbhV0nDlc7C15XoUTZVXX8i9jMDK@ "JavaScript (Babel Node) – Try It Online")
---
# [JavaScript (Babel Node)](https://babeljs.io/), 44 bytes
*If the input can be taken as String*
```
f=a=>a>9?[a,...f(''+eval([...a].join`*`))]:a
```
[Try it online!](https://tio.run/##JcrdCkAwGAbgy9nm5yvKAYULQe3FaGvtE3L7oxw@9Tg8uJbTHnc@YzY@D7yaGLcWbYeu7gdkRLRJIVLzwMvhEyZybINOtFJTg7hwuNgb8rzLb1ZFKdQ/xqBVfAE "JavaScript (Babel Node) – Try It Online")
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~64~~ 59 bytes
```
for($a="$args";9-lt$a){$a;$a="$(($a|% t*y)-join'*'|iex)"}$a
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/Py2/SEMl0VZJJbEovVjJ2lI3p0QlUbNaJdEaLKoBlKxRVSjRqtTUzcrPzFPXUq/JTK3QVKpVSfz//7@RORhYgIGlJQA "PowerShell – 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 `t`oCharArra`y`, `join`ing 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.*
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 13 bytes
```
θＷ⊖Ｌθ«≔ＩΠθθ⸿θ
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRKNQ05qrPCMzJ1VBwyU1uSg1NzWvJDVFwyc1L70kAyirqalQzcXpWFycmZ6n4ZxYXKIRUJSfUpoM0qmpowDSzgkxSSmmSAnBA0nU/v9vZA4GFmBgaflftywHAA "Charcoal – 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.
]