Voici une séquence intéressante découverte par Paul Loomis, mathématicien à l'Université de Bloomsburg. De sa page sur cette séquence:

Définissez
f(n) = f(n-1) + (the product of the nonzero digits of f(n-1))
f(0) = x, avec xcomme tout entier positif, écrit en base 10.

Donc, en commençant par f(0)=1, vous obtenez la séquence suivante
1, 2, 4, 8, 16, 22, 26, 38, 62, 74, 102, 104, ...

Jusqu'à présent, si standard. La propriété intéressante entre en jeu lorsque vous prenez n'importe quel autre entier comme point de départ, finalement la séquence converge en un point le long de la x=1séquence ci-dessus . Par exemple, en commençant par les x=3rendements
3, 6, 12, 14, 18, 26, 38, 62, 74, 102, ...

Voici quelques séquences supplémentaires, chacune affichée uniquement jusqu'à ce qu'elles atteignent 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, ...

Il a conjecturé, et prouvé empiriquement jusqu'à x=1,000,000, que cette propriété (c'est-à-dire que tous les nombres d'entrée convergent vers la même séquence) est vraie.

Le défi

Étant donné un entier positif 0 < x < 1,000,000, affichez le nombre où la f(x)séquence converge vers la f(1)séquence. Par exemple, pour x=5, ce serait 26, puisque c'est le premier nombre commun aux deux séquences.

 x output
 1 1
 5 26
19 102
63 150056

Règles

• Le cas échéant, vous pouvez supposer que l'entrée / sortie s'adaptera au type Integer natif de votre langue.
• L'entrée et la sortie peuvent être fournies par n'importe quelle méthode pratique .
• Un programme complet ou une fonction sont acceptables. S'il s'agit d'une fonction, vous pouvez renvoyer la sortie plutôt que de l'imprimer.
• Les failles standard sont interdites.
• Il s'agit de code-golf, donc toutes les règles de golf habituelles s'appliquent et le code le plus court (en octets) l'emporte.

JavaScript (ES6), 81 67 octets

1 octet enregistré grâce à @ l4m2

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

Essayez-le en ligne!

Commenté

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

Gelée , 18 14 octets

ḊḢDo1P+Ʋ;µQƑ¿Ḣ

L'entrée est un tableau singleton.

Essayez-le en ligne!

Comment ça marche

ḊḢ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 octets

Utilisation du déballage replace(*'01')comme dans @Rod answer
-18 octets grâce à @Lynn

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

Essayez-le en ligne!

Haskell , 65 octets

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

Essayez-le en ligne!

Python 2 , 78 octets

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

Essayez-le en ligne!

Husk , 13 octets

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

Prend l'entrée en tant que liste singleton.

Essayez-le en ligne!

Explication

                 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 , 126 125 octets

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

Essayez-le en ligne!

Prenez l'entrée comme chaîne

Java (JDK 10) , 99 octets

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;}

Essayez-le en ligne!

Principalement un port itératif de la réponse JavaScript d' Arnauld , alors allez le voter!

Gelée , 23 octets

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

Essayez-le en ligne!

J , 50 octets

définition de la fonction de style tacite

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

si l'argument (disons 63) était collé dans une expression REPL, cela pourrait être 45 par exemple

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

• ,&1 ajouter 1 pour générer la séquence de recherche ainsi que la séquence d'argument
• ^:(<453)"0 itère chacun jusqu'à ce que 1 million soit atteint dans la séquence de 1
• + [: */@(*#]) (#~10)&#: la fourchette s'ajoute au crochet qui fait le produit des chiffres
• (e.~ # ])/ utilise l'élément répété s'il existe pour obtenir l'intersection des listes
• {. ne renvoie que la première valeur commune

Essayez-le en ligne!

R , 110 86 octets

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

version précédente 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