22

Aquí hay una secuencia interesante descubierta por Paul Loomis, matemático de la Universidad de Bloomsburg. De su página en esta secuencia:

Definir
f(n) = f(n-1) + (the product of the nonzero digits of f(n-1))
f(0) = x, con xcualquier número entero positivo, escrito en base 10.

Entonces, comenzando f(0)=1, obtienes la siguiente secuencia
1, 2, 4, 8, 16, 22, 26, 38, 62, 74, 102, 104, ...

Hasta ahora, tan estándar. La propiedad interesante entra en juego cuando tomas cualquier otro número entero como punto de partida, eventualmente la secuencia converge en un punto a lo largo de la x=1secuencia anterior . Por ejemplo, comenzando con x=3rendimientos
3, 6, 12, 14, 18, 26, 38, 62, 74, 102, ...

Éstos son algunos más secuencias, cada muestra solamente hasta que llegan 102:

5, 10, 11, 12, 14, 18, 26, 38, 62, 74, 102, ...
7, 14, 18, 26, 38, 62, 74, 102, ...
9, 18, 26, 38, 62, 74, 102, ...
13, 16, 22, 26, 38, 62, 74, 102, ...
15, 20, 22, 26, 38, 62, 74, 102, ...
17, 24, 32, 38, 62, 74, 102, ...
19, 28, 44, 60, 66, 102, ...

Conjeturó y demostró empíricamente x=1,000,000que esta propiedad (es decir, que todos los números de entrada convergen en la misma secuencia) es cierta.

El reto

Dado un entero de entrada positivo 0 < x < 1,000,000, emite el número donde la f(x)secuencia converge a la f(1)secuencia. Por ejemplo, para x=5, esto sería 26, ya que ese es el primer número en común para ambas secuencias.

Reglas

Si corresponde, puede suponer que la entrada / salida se ajustará al tipo entero nativo de su idioma.
La entrada y salida se pueden dar por cualquier método conveniente .
Un programa completo o una función son aceptables. Si es una función, puede devolver el resultado en lugar de imprimirlo.
Las lagunas estándar están prohibidas.
Este es el código de golf, por lo que se aplican todas las reglas habituales de golf, y gana el código más corto (en bytes).

code-golf sequence number-theory

— AdmBorkBork
fuente

5

JavaScript (ES6), 81 67 bytes

Guardado 1 byte gracias a @ l4m2

f=(n,x=1)=>x<n?f(x,n):x>n?f(+[...n+''].reduce((p,i)=>p*i||p)+n,x):n

Pruébalo en línea!

Comentado

f = (n,                   // n = current value for the 1st sequence, initialized to input
        x = 1) =>         // x = current value for the 2nd sequence, initialized to 1
  x < n ?                 // if x is less than n:
    f(x, n)               //   swap the sequences by doing a recursive call to f(x, n)
  :                       // else:
    x > n ?               //   if x is greater than n:
      f(                  //     do a recursive call with the next term of the 1st sequence:
        +[...n + '']      //       coerce n to a string and split it
        .reduce((p, i) => //       for each digit i in n:
          p * i || p      //         multiply p by i, or let p unchanged if i is zero
        ) + n,            //       end of reduce(); add n to the result
        x                 //       let x unchanged
      )                   //     end of recursive call
    :                     //   else:
      n                   //     return n

— Arnauld
fuente

`` `` f = (n, x = 1) => x <n? f (x, n): x> n? f (+ [... n + '']. reduce ((p, i) = > p * i || p) + n, x): n `` ``

— l4m2

4

Jalea , 18 14 bytes

ḊḢDo1P+Ʋ;µQƑ¿Ḣ

La entrada es una matriz singleton.

Pruébalo en línea!

Cómo funciona

ḊḢDo1P+Ʋ;µQƑ¿Ḣ  Main link. Argument: [n]

            ¿   While...
          QƑ      all elements of the return value are unique...
         µ          execute the chain to the left.
Ḋ                     Dequeue; remove the first item.
 Ḣ                    Head; extract the first item.
                      This yields the second item of the return value if it has
                      at least two elements, 0 otherwise.
       Ʋ              Combine the links to the left into a chain.
  D                     Take the decimal digits of the second item.
   o1                   Perform logical OR with 1, replacing 0's with 1's.
     P                  Take the product.
      +                 Add the product with the second item.
        ;             Prepend the result to the previous return value.
             Ḣ  Head; extract the first item.

— Dennis
fuente

2

Python 2 , 111 95 93 bytes

Utilizando el desempaquetado replace(*'01')como en @Rod responde
-18 bytes gracias a @Lynn

l=[1,input()]
while cmp(*l):l[0]+=eval('*'.join(`l[0]`.replace(*'01')));l.sort()
print l[0]

Pruébalo en línea!

— Zarigüeya muerta
fuente

1

¡Ah, y la condición del bucle también puede ser while cmp(*l)!

— Lynn el

@ Lynn ¡Sí! Gracias de nuevo

— Dead Possum

2

Haskell , 65 bytes

(!1)
a!b|a>b=b!a|a<b=(a+product[read[d]|d<-show a,d>'0'])!b|1<2=a

Pruébalo en línea!

— Lynn
fuente

2

Python 2 , 78 bytes

f=lambda a,b=1:a*(a==b)or f(*sorted([a+eval('*'.join(`a`.replace(*'01'))),b]))

Pruébalo en línea!

— Lynn
fuente

Estaba trabajando en la solución con lambda, pero me quedé atrapado con un cortocircuito durante un par de minutos, ¡buen trabajo!

— Dead Possum

2

Casco , 13 bytes

→UΞm¡S+ȯΠf±dΘ

Toma la entrada como una lista singleton.

Pruébalo en línea!

Explicación

                 Implicit input, e.g 5
            Θ    Prepend a zero to get  [0,5]
   m             Map the following over [0,5]
    ¡              Iteratatively apply the following function, collecting the return values in a list
           d         Convert to a list of digits
         f±          keep only the truthy ones
       ȯΠ            then take the product
     S+              add that to the original number
                After this map, we have [[0,1,2,4,8,16,22,26,38,62...],[5,10,11,12,14,18,26,38,62,74...]]
  Ξ             Merge the sorted lists:  [0,1,2,4,5,8,10,11,12,14,16,18,22,26,26,38,38,62,62,74...]
 U              Take the longest unique prefix: [0,1,2,4,5,8,10,11,12,14,16,18,22,26]
→               Get the last element and implicitely output: 26

— H.PWiz
fuente

1

Python 3 , 126125 bytes

m=[1]
n=[int(input())]
while not{*m}&{*n}:
 for l in m,n:l+=l[-1]+eval('*'.join(str(l[-1]).replace(*'01'))),
print({*m}&{*n})

Pruébalo en línea!

Toma la entrada como cadena

— Barra
fuente

1

Java (JDK 10) , 99 bytes

n->{for(int x=1;x!=n;n+=(""+n).chars().reduce(1,(a,b)->a*(b>48?b-48:1)))x^=x<n?n^(n=x):0;return n;}

Pruébalo en línea!

Principalmente un puerto iterativo de la respuesta de JavaScript de Arnauld , ¡así que vota!

— Olivier Grégoire
fuente

0

Jalea , 23 bytes

ð⁹1,Dḟ0P+Ʋ⁸Ð¡€f/©µ1#ṛ®Ḣ

Pruébalo en línea!

— Erik el Outgolfer
fuente

0

J , 50 bytes

definición de función de estilo tácito

[:{.@(e.~#])/[:(+[:*/@(*#])(#~10)&#:)^:(<453)"0,&1

si el argumento (por ejemplo, 63) se pegara en una expresión REPL, podría ser 45 por ejemplo

{.(e.~#])/(+[:*/@(*#])(#~10)&#:)^:(<453)"0]1,63

,&1 agregar 1 para generar la secuencia de búsqueda, así como la secuencia de argumentos
^:(<453)"0 itera cada uno hasta que se alcanza 1 millón en la secuencia de 1
+ [: */@(*#]) (#~10)&#: tenedor agrega al gancho que hace el producto de dígitos
(e.~ # ])/ usa el elemento de repetición si existe para obtener la intersección de las listas
{. devuelve solo el primer valor común

Pruébalo en línea!

— jayprich
fuente

0

R , 110 86 bytes

o=c(1,1:9);o=o%o%o%o%o;o=c(o%o%o)
x=c(1,n);while((x=sort(x))<x[2])x[1]=(x+o[x+1])[1]
x

TIO

versión anterior 110:

f=function(x){if((x[1]=x[1]+(c((y=(y=c(1,1:9))%o%y%o%y)%o%y))[x[1]+1])==x[2]){x[1]}else{f(sort(x))}}
f(c(1,n))

TIO

— jayprich
fuente

Secuencias de productos de dígitos

El reto

Reglas

JavaScript (ES6), 81 67 bytes

Comentado

Jalea , 18 14 bytes

Cómo funciona

Python 2 , 111 95 93 bytes

Haskell , 65 bytes

Python 2 , 78 bytes

Casco , 13 bytes

Explicación

Python 3 , 126125 bytes

Java (JDK 10) , 99 bytes

Jalea , 23 bytes

J , 50 bytes

R , 110 86 bytes