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.

 x output
 1 1
 5 26
19 102
63 150056

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

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

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.

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!

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!

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!

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

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

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!

Jalea , 23 bytes

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

Pruébalo en línea!

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!

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