다음은 Bloomsburg University의 수학자 Paul Loomis가 발견 한 흥미로운 순서입니다. 에서 자신의 페이지에 이 순서에 :

정의
f(n) = f(n-1) + (the product of the nonzero digits of f(n-1))
f(0) = x와, x베이스 (10)에 기록 된 양의 정수로.

따라서로 시작 f(0)=1하면 다음과 같은 시퀀스가 ​​나타납니다.
1, 2, 4, 8, 16, 22, 26, 38, 62, 74, 102, 104, ...

지금까지는 표준입니다. 흥미로운 속성은 다른 정수를 시작점으로 사용할 때 시작되며 결국 시퀀스는 위의 x=1시퀀스를 따라 포인트로 수렴됩니다 . 예를 들어 x=3수율로 시작
3, 6, 12, 14, 18, 26, 38, 62, 74, 102, ...

여기에 도달 할 때까지만 표시되는 시퀀스가 ​​더 있습니다 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, ...

그는 x=1,000,000이 특성 (즉, 모든 입력 숫자가 동일한 순서로 수렴 됨)이 사실임을 추측하고 실험적으로 입증했다 .

도전

양의 입력 정수가 주어지면 시퀀스가 시퀀스에 수렴 0 < x < 1,000,000하는 숫자를 출력하십시오 . 예를 들어, 이것은 두 시퀀스에 공통 인 첫 번째 숫자이므로입니다.f(x)f(1)x=526

 x output
 1 1
 5 26
19 102
63 150056

규칙

• 해당되는 경우 입력 / 출력이 해당 언어의 고유 정수 유형에 맞는 것으로 가정 할 수 있습니다.
• 입력 및 출력은 편리한 방법 으로 제공 할 수 있습니다 .
• 전체 프로그램 또는 기능이 허용됩니다. 함수 인 경우 출력하지 않고 출력을 반환 할 수 있습니다.
• 표준 허점 은 금지되어 있습니다.
• 이것은 코드 골프 이므로 모든 일반적인 골프 규칙이 적용되며 가장 짧은 코드 (바이트)가 이깁니다.

자바 스크립트 (ES6), 81 67 바이트

@ l4m2 덕분에 1 바이트 절약

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

온라인으로 사용해보십시오!

댓글

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

젤리 , 18 14 바이트

ḊḢDo1P+Ʋ;µQƑ¿Ḣ

입력은 싱글 톤 배열입니다.

온라인으로 사용해보십시오!

작동 원리

ḊḢ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 , 111 95 93 바이트

replace(*'01')@Lynn 덕분 에 @Rod answer
-18 바이트 와 같이 압축 풀기 사용

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

온라인으로 사용해보십시오!

하스켈 , 65 바이트

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

온라인으로 사용해보십시오!

파이썬 2 , 78 바이트

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

온라인으로 사용해보십시오!

껍질 , 13 바이트

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

단일 목록으로 입력을받습니다.

온라인으로 사용해보십시오!

설명

                 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

파이썬 3 , 126125 바이트

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

온라인으로 사용해보십시오!

문자열로 입력을 받아

자바 (JDK 10) , 99 바이트

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

온라인으로 사용해보십시오!

대부분 Arnauld의 JavaScript 답변의 반복 포트 이므로 그를 투표하십시오!

젤리 , 23 바이트

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

온라인으로 사용해보십시오!

J , 50 바이트

암묵적 스타일 함수 정의

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

인수 (예 : 63)가 REPL 표현식에 붙여 넣은 경우 45 일 수 있습니다.

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

• ,&1 1을 추가하여 검색 순서와 인수 순서를 생성하십시오.
• ^:(<453)"0 1의 순서대로 1mio에 도달 할 때까지 각각 반복
• + [: */@(*#]) (#~10)&#: 포크는 숫자의 곱을 수행하는 후크에 추가합니다.
• (e.~ # ])/ 존재하는 경우 반복 항목을 사용하여 목록의 교차점을 얻습니다.
• {. 첫 번째 공통 값만 반환

온라인으로 사용해보십시오!

R , 110 86 바이트

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

이전 버전 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