Ecco una sequenza interessante scoperta da Paul Loomis, un matematico alla Bloomsburg University. Dalla sua pagina su questa sequenza:

Definisci
f(n) = f(n-1) + (the product of the nonzero digits of f(n-1))
f(0) = x, con xcome qualsiasi numero intero positivo, scritto nella base 10.

Quindi, a partire da f(0)=1, ottieni la seguente sequenza
1, 2, 4, 8, 16, 22, 26, 38, 62, 74, 102, 104, ...

Finora, così standard. La proprietà interessante entra in gioco quando prendi qualsiasi altro numero intero come punto iniziale, alla fine la sequenza converge in un punto lungo la x=1sequenza sopra . Ad esempio, a partire dai x=3rendimenti
3, 6, 12, 14, 18, 26, 38, 62, 74, 102, ...

Ecco alcune altre sequenze, ognuna mostrata solo fino a quando non raggiungono 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, ...

Ha ipotizzato, e empiricamente dimostrato x=1,000,000, che questa proprietà (cioè che tutti i numeri di input convergono nella stessa sequenza) è vera.

La sfida

Dato un numero intero di input positivo 0 < x < 1,000,000, emettere il numero in cui la f(x)sequenza converge alla f(1)sequenza. Ad esempio, per x=5, questo sarebbe 26, poiché questo è il primo numero in comune per entrambe le sequenze.

 x output
 1 1
 5 26
19 102
63 150056

Regole

• Se applicabile, puoi supporre che l'input / output si adatti al tipo intero nativo della tua lingua.
• L'input e l'output possono essere forniti con qualsiasi metodo conveniente .
• È accettabile un programma completo o una funzione. Se una funzione, è possibile restituire l'output anziché stamparlo.
• Sono vietate le scappatoie standard .
• Si tratta di code-golf quindi si applicano tutte le normali regole del golf e vince il codice più breve (in byte).

JavaScript (ES6), 81 67 byte

Salvato 1 byte grazie a @ l4m2

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

Provalo online!

Commentate

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

Gelatina , 18 14 byte

ḊḢDo1P+Ʋ;µQƑ¿Ḣ

L'input è un array singleton.

Provalo online!

Come funziona

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

Usando il disimballaggio replace(*'01')come nella risposta @Rod
-18 byte grazie a @Lynn

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

Provalo online!

Haskell , 65 byte

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

Provalo online!

Python 2 , 78 byte

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

Provalo online!

Buccia , 13 byte

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

Accetta input come un elenco singleton.

Provalo online!

Spiegazione

                 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 byte

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

Provalo online!

Prendi l'input come stringa

Java (JDK 10) , 99 byte

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

Provalo online!

Principalmente una porta iterativa della risposta JavaScript di Arnauld , quindi votalo!

Gelatina , 23 byte

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

Provalo online!

J , 50 byte

definizione della funzione stile tacito

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

se l'argomento (diciamo 63) fosse incollato in un'espressione REPL potrebbe essere 45 ad es

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

• ,&1 append 1 per generare la sequenza di ricerca e la sequenza dell'argomento
• ^:(<453)"0 scorre ciascuna fino a quando non viene raggiunto 1mio nella sequenza di 1
• + [: */@(*#]) (#~10)&#: la forcella aggiunge al gancio che fa il prodotto delle cifre
• (e.~ # ])/ usa l'elemento di ripetizione se esiste per ottenere l'intersezione degli elenchi
• {. restituisce solo il primo valore comune

Provalo online!

R , 110 86 byte

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

versione precedente 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