Persistencia Multiplicativa

46

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 :

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.

code-golf math arithmetic repeated-transformation SQB
fuente
Bonificación: encuentre un nuevo registro: el número más pequeño con el mayor número de pasos. Advertencia: la conjetura dice que 11 es el más grande posible.
SQB
77
Probablemente debería incluir algunos casos de pruebas más que no terminen en . 0
Arnauld
Vine a hacer esta publicación, la encontré ya existente, gg
cat
es una entrada válida de un solo dígito?
dzaima
1
En el video de Numberphile, Matt Parker afirma que se han realizado búsquedas en varios cientos de dígitos.
HardScale

Respuestas:

7

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.

Nick Kennedy
fuente
15

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.

Tau
fuente
¿Puede guardar un byte moviéndose 10^(afuera seq(y omitiendo el paréntesis de cierre?
Solomon Ucko
¡Sí, así lo creo!
Tau
11

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

ngn
fuente
8

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.

Giuseppe
fuente
8

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
Kevin Cruijssen
fuente
7

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!

Jonathan Allan
fuente
Puedes hacerlo >en lugar de and.
xnor
@xnor gracias, fácil de olvidar que funcionará.
Jonathan Allan
5

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.

KGlasier
fuente
5

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!

Encarnación de la ignorancia
fuente
5

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
640 KB
fuente
5

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

TFeld
fuente
No funciona para entradas que no terminan con un 0 en su última iteración, por ejemplo 23
Realización de la ignorancia
int.__mul__es tres bytes menos quelambda a,b:a*b
Jonathan Allan
@JonathanAllan ¡Gracias! Sabía que tenía que haber algo así
TFeld
Cambie f(reduce(int.__mul__,map(int,`n`)))a f(eval('*'.join(`n`)))para guardar 13 bytes.
mypetlion
@mypetlion ... Ya lo hice en otra publicación.
Jonathan Allan
5

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

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

25 bytes

30 bytes

32 bytes

Nahuel Fouilleul
fuente
Debe mencionar que esto usa-lpF//
Grimmy
1
@ Grimy podría guardar 2 bytes sin usar -lpF//, actualizando
Nahuel Fouilleul
5

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)
maxb
fuente
La salida para una entrada de un solo dígito debe ser una copia del número - aclarado en los comentarios
dzaima
@dzaima Lo investigaré y actualizaré la respuesta cuando se resuelva
maxb
4

JavaScript (ES6), 45 bytes

Devuelve una matriz de enteros.

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

Pruébalo en línea!

Arnauld
fuente
4

APL (NARS), 19 caracteres, 38 bytes

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

prueba:

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

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
Lanudo
fuente
3

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
Fatalizar
fuente
Lo intenté yo mismo. Olvidé el the. El resto tuve lo mismo.
Kroppeb
3

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.

AdmBorkBork
fuente
Puede usar la comparación en 9-lt$alugar de $a.length-1guardar 5 bytes. Y si no te fueras todo el tiempo, podrías cortar un trozo decente. ¡Mira mi intento de PowerShell si quieres!
KGlasier
3

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.

Neil
fuente
3

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`.
Neil
fuente
3

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 ...

attinat
fuente