Sequências de produtos com dígitos


22

Aqui está uma sequência interessante descoberta por Paul Loomis, matemático da Universidade de Bloomsburg. De sua página nesta sequência:

Defina
f(n) = f(n-1) + (the product of the nonzero digits of f(n-1))
f(0) = x, xcomo qualquer número inteiro positivo, escrito na base 10.

Então, começando com f(0)=1, você obtém a seguinte sequência
1, 2, 4, 8, 16, 22, 26, 38, 62, 74, 102, 104, ...

Até agora, tão padrão. A propriedade interessante entra em jogo quando você toma qualquer outro número inteiro como ponto de partida; eventualmente, a sequência converge para um ponto ao longo da x=1sequência acima . Por exemplo, começando com x=3rendimentos
3, 6, 12, 14, 18, 26, 38, 62, 74, 102, ...

Aqui estão mais algumas sequências, cada uma exibida apenas até atingirem 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, ...

Ele conjeturou, e provou empiricamente x=1,000,000, que essa propriedade (isto é, que todos os números de entrada convergem para a mesma sequência) é verdadeira.

O desafio

Dado um número inteiro positivo, insira 0 < x < 1,000,000o número em que a f(x)sequência converge para a f(1)sequência. Por exemplo, para x=5isso seria 26, pois esse é o primeiro número em comum para as duas seqüências.

 x output
 1 1
 5 26
19 102
63 150056

Regras

  • Se aplicável, você pode supor que a entrada / saída caiba no tipo Inteiro nativo do seu idioma.
  • A entrada e saída podem ser fornecidas por qualquer método conveniente .
  • Um programa completo ou uma função são aceitáveis. Se uma função, você pode retornar a saída em vez de imprimi-la.
  • As brechas padrão são proibidas.
  • Isso é portanto todas as regras usuais de golfe se aplicam e o código mais curto (em bytes) vence.

Respostas:


5

JavaScript (ES6), 81 67 bytes

Guardado 1 byte graças a @ l4m2

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

Experimente online!

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

`` `` f = (n, x = 1) => x <n? f (x, n): x> n? f (+ [... n + ''] .reduzir ((p, i) = > p * i || p) + n, x): n `` `
l4m2 23/04/19

4

Geléia , 18 14 bytes

ḊḢDo1P+Ʋ;µQƑ¿Ḣ

A entrada é uma matriz singleton.

Experimente online!

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




2

Casca , 13 bytes

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

Recebe entrada como uma lista de singleton.

Experimente online!

Explicação

                 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

1

Python 3 , 126 125 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})

Experimente online!

Tome a entrada como string




0

J , 50 bytes

definição de função de estilo tácito

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

se o argumento (digamos 63) fosse colado em uma expressão REPL, poderia ser 45, por exemplo

{.(e.~#])/(+[:*/@(*#])(#~10)&#:)^:(<453)"0]1,63
  • ,&1 acrescente 1 para gerar a sequência de pesquisa e a sequência do argumento
  • ^:(<453)"0 itera cada um até que 1 milhão seja alcançado na sequência de 1
  • + [: */@(*#]) (#~10)&#: garfo acrescenta ao gancho que faz o produto dos dígitos
  • (e.~ # ])/ usa item repetido se existir para obter a interseção de listas
  • {. retorna apenas o primeiro valor comum

Experimente online!


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

versão 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

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.