Persistencia Multiplicativa

1. Multiplica todos los dígitos en un número
2. Repita hasta que le quede un solo dígito

Como lo explica Numberphile :

• Numberphile "¿Qué tiene de especial 277777788888899?"
• Numberphile "Persistencia Multiplicativa (metraje extra)"

Ejemplo

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

Este es el registro actual, por cierto: el número más pequeño con el mayor número de pasos.

Golf

Un programa que toma cualquier número entero como entrada y luego emite el resultado de cada paso, comenzando con la entrada en sí, hasta que lleguemos a un solo dígito. Para 277777788888899, la salida debe ser

277777788888899
4996238671872
438939648
4478976
338688
27648
2688
768
336
54
20
0

(Contar el número de pasos se deja como ejercicio para el usuario).

Más ejemplos

De A003001 :

25
10
0

De A003001 también:

68889
27648
2688
768
336
54
20
0

Del video de Numberphile :

327
42
8

Entonces ha habido una pregunta sobre la Persistencia Aditiva , pero esta es la Persistencia Multiplicativa. Además, esa pregunta pide la cantidad de pasos como salida, mientras que estoy interesado en ver los resultados intermedios.

Jalea , 4 bytes

DP$Ƭ

Pruébalo en línea!

Explicación

D    | convert to decimal digits
 P   | take the product
  $  | previous two links as a monad
   Ƭ | loop until no change, collecting all intermediate results

Como beneficio adicional, aquí hay un TIO que encontrará los números con el mayor número de pasos para un rango dado de números de dígitos. Se escala bien incluso en TIO.

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

-1 byte gracias a @SolomonUcko!

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

La entrada está adentro Ans.
La salida se muestra como las solicitudes de desafío. El final Anses necesario para imprimir el último paso.

Debo admitir que no pensé en esta fórmula, sino que la encontré aquí y la modifiqué para que se ajustara mejor al desafío.

EDITAR: Al volver a leer el desafío, me di cuenta de que el programa debe terminar si el producto tiene un dígito. Por lo tanto, se agregaron 2 bytes para dar cuenta de esto.

Ejemplo:

24456756
        24456756
prgmCDGF8
        24456756
          201600
               0
11112
           11112
prgmCDGF8
           11112
               2

Explicación:

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

Modelo visual:
Ans comienza como 125673.
Este modelo solo cubre la lógica detrás de multiplicar los dígitos; todo lo demás es más fácil de entender.

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)

Notas:

TI-BASIC es un lenguaje tokenizado. El recuento de caracteres no es igual al recuento de bytes.

10^(es este token de un byte .

Este programa no proporcionará la secuencia correcta de productos con enteros mayores de 14 dígitos debido a las limitaciones de precisión decimal en las calculadoras TI.

K (ngn / k) , 9 bytes

{*/.'$x}\

Pruébalo en línea!

{ }\ sigue aplicando la función entre llaves hasta que la secuencia converja

$x formatear el argumento como una cadena (lista de caracteres)

.'evaluar cada uno (otros dialectos de k requieren dos puntos .:')

*/ veces, es decir, producto

dzaima / APL , 14 11 bytes

∪{×/⍎¨⍕⍵}⍡≡

Pruébalo en línea!

R , 59 bytes

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

Pruébalo en línea!

Como print invisiblydevuelve su entrada, podemos usar print(n)dentro del whilebucle para simular un do-whilebucle. Esto es inspirada por uno de mis consejos para jugar al golf en I .

El encabezado ayuda a evitar que se impriman grandes números en notación científica.

05AB1E , 7 4 bytes

Δ=SP

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

Δ     # 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

Wolfram Language (Mathematica) , 47 bytes

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

Pruébalo en línea!

Wolfram Language (Mathematica) , 45 bytes

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

Pruébalo en línea!

Perl 6 , 23 bytes

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

Pruébalo en línea!

Python 2 ,  46  43 bytes

-3 gracias a xnor (comparación encadenada)

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

Pruébalo en línea!

PowerShell , 54 bytes

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

Pruébalo en línea!

Método iterativo que primero escribe el argumento de entrada, luego lo convierte en una cadena y lo canaliza en una matriz de caracteres. Esta matriz está unida por un solo asterisco y se ejecuta como un comando con el alias de expresión de invocación. Como esto escribe el número inicial hasta el último número mayor que 0, (20, en el escenario de prueba dado), agrego un final $aal final para la salida.

C # (compilador interactivo de Visual C #) , 79 74 68 bytes

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

Intento mantenerme alejado de la recursividad en C # debido a la duración de la declaración del método, pero en este caso se guarda en comparación con un bucle.

Pruébalo en línea!

PHP , 63 bytes

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

Versión iterativa, llamada con php -nFentrada de STDIN.

Pruébalo en línea!

PHP ,72 71 bytes

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

Pruébalo en línea!

Versión recursiva, como función.

Entrada: 277777788888899

277777788888899
4996238671872
438939648
4478976
338688
27648
2688
768
336
54
20
0

Entrada: 23

23
6

Python 2 , 61 62 59 bytes

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

Pruébalo en línea!

_{-3 bytes, gracias a 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(→

Pruébalo en línea!

Ahora maneja correctamente las entradas que son de un solo dígito. No es perfecto, pero al menos es correcto.

Explicación

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)

Julia 0.7 , 36 33 bytes

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

Pruébalo en línea!

Gracias a H.PWiz por -3 bytes.

JavaScript (ES6), 45 bytes

Devuelve una matriz de enteros.

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

Pruébalo en línea!

PowerShell , 51 bytes

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

Pruébalo en línea!

APL (NARS), 19 caracteres, 38 bytes

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

prueba:

   f←{⍵≤9:⍵⋄∇×/⍎¨⍕⍵⊣⎕←⍵}
   f 23     
23
6
   f 27648     
27648
2688
768
336
54
20
0

Haskell, 45 bytes

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

Pruébalo en línea!

J , 16 bytes

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

Pruébalo en línea!

Ruby , 38 35 34 bytes

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

Pruébalo en línea!

1 byte guardado por G B.

Japt -R , 9 bytes

Horriblemente ineficiente, ¡ni siquiera intentes ejecutar el primer caso de prueba!

_ì ×}hN â

Intentalo

_ì ×}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

Brachylog , 7 bytes

ẉ?Ḋ|ẹ×↰

Pruébalo en línea!

Explicación

ẉ          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 (nodo de Babel) , 46 bytes

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

Pruébalo en línea!

JavaScript (nodo de Babel) , 44 bytes

Si la entrada se puede tomar como String

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

Pruébalo en línea!

PowerShell , 64 59 bytes

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

Pruébalo en línea!

Método iterativo Toma la entrada y la almacena $a, luego ingresa un forbucle siempre que la longitud $asea ​​dos o más (es decir, es mayor que 9). Dentro del bucle sacamos $ay luego lo recalculamos convirtiéndolo en toCharArra y, uniéndolo joincon *, y luego iex(abreviatura Invoke-Expressiony similar a eval). Una vez que estamos fuera del ciclo, nos queda un solo dígito para imprimir, por lo que colocamos $anuevamente en la tubería.

-5 bytes gracias a KGlasier.

Carbón , 13 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

θ

Imprime la entrada por primera vez.

Ｗ⊖Ｌθ«

Repita mientras la longitud de la entrada no sea 1.

≔ＩΠθθ

Reemplace la entrada con su producto digital fundido a cadena.

⸿θ

Imprima la entrada en una nueva línea.

Retina , 24 bytes

.+~(\`

.
$&$*
^
.+¶$$.(

Pruébalo en línea! Explicación:

.+~(\`

Imprima el valor actual en su propia línea al comienzo de cada ciclo hasta que deje de cambiar y no imprima el valor sin cambios dos veces. Evaluar el valor actual al final de cada ciclo.

.
$&$*

Agregue un *después de cada dígito.

^
.+¶$$.(

Termine de convertir la entrada en una expresión que evalúe el producto digital.

Solo para el registro, Retina puede hacer esto en una línea (25 bytes):

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

C (gcc) , 58 bytes

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

Pruébalo en línea!

El enfoque iterativo resulta ser 1 byte más corto.

f(n,t){
    for(;n=printf("%d\n",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 (recursivo)

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

Pruébalo en línea!

La recursión parece ser más corta que la iteración tanto para la impresión como para el paso ...