22

Đây là một chuỗi thú vị được phát hiện bởi Paul Loomis, một nhà toán học tại Đại học Bloomsburg. Từ trang của anh ấy về trình tự này:

Xác định
f(n) = f(n-1) + (the product of the nonzero digits of f(n-1))
f(0) = x, với xbất kỳ số nguyên dương nào, được viết trong cơ sở 10.

Vì vậy, bắt đầu với f(0)=1, bạn có được trình tự sau đây
1, 2, 4, 8, 16, 22, 26, 38, 62, 74, 102, 104, ...

Cho đến nay, rất chuẩn. Thuộc tính thú vị phát huy tác dụng khi bạn lấy bất kỳ số nguyên nào khác làm điểm bắt đầu, cuối cùng chuỗi sẽ hội tụ thành một điểm dọc theo x=1chuỗi trên . Ví dụ: bắt đầu với x=3sản lượng
3, 6, 12, 14, 18, 26, 38, 62, 74, 102, ...

Dưới đây là một số trình tự khác, mỗi trình tự chỉ được hiển thị cho đến khi chúng đạt đến 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, ...

Ông phỏng đoán và chứng minh bằng thực nghiệm x=1,000,000rằng tính chất này (nghĩa là tất cả các số đầu vào hội tụ vào cùng một chuỗi) đều đúng.

Các thách thức

Cho một số nguyên đầu vào dương 0 < x < 1,000,000, xuất số trong đó f(x)chuỗi hội tụ đến f(1)chuỗi. Ví dụ, đối với x=5điều này sẽ là 26, vì đó là số đầu tiên chung cho cả hai chuỗi.

Quy tắc

Nếu có thể, bạn có thể giả sử rằng đầu vào / đầu ra sẽ phù hợp với loại Số nguyên gốc của ngôn ngữ của bạn.
Đầu vào và đầu ra có thể được cung cấp bởi bất kỳ phương pháp thuận tiện .
Một chương trình đầy đủ hoặc một chức năng được chấp nhận. Nếu một chức năng, bạn có thể trả lại đầu ra thay vì in nó.
Sơ hở tiêu chuẩn bị cấm.
Đây là môn đánh gôn, vì vậy tất cả các quy tắc chơi gôn thông thường đều được áp dụng và mã ngắn nhất (tính bằng byte) sẽ thắng.

code-golf sequence number-theory

— AdBorkBork
nguồn

5

JavaScript (ES6), 81 67 byte

Đã lưu 1 byte nhờ @ l4m2

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

Hãy thử trực tuyến!

Đã bình luậ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

— Arnauld
nguồn

`` `` f = (n, x = 1) => x <n? F (x, n): x> n? F (+ [... n + '']. giảm ((p, i) = > p * i | | p) + n, x): n `` ``

— l4m2

4

Thạch , 18 14 byte

ḊḢDo1P+Ʋ;µQƑ¿Ḣ

Đầu vào là một mảng đơn.

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

— Dennis
nguồn

2

Python 2 , 111 95 93 byte

Sử dụng giải nén replace(*'01')như trong @Rod trả lời
-18 byte nhờ @Lynn

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

Hãy thử trực tuyến!

— Xác chết
nguồn

1

Ah, và điều kiện vòng lặp cũng có thể while cmp(*l)!

— Lynn

@Lynn Vâng! Cảm ơn một lần nữa

— Dead Possum

2

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

Hãy thử trực tuyến!

— Lynn
nguồn

2

Python 2 , 78 byte

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

Hãy thử trực tuyến!

— Lynn
nguồn

Tôi đã làm việc với giải pháp với lambda, nhưng bị mắc kẹt với chu kỳ ngắn trong vài phút, công việc tốt!

— Dead Possum

2

Husk , 13 byte

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

Đưa đầu vào như một danh sách đơn.

Hãy thử trực tuyến!

Giải trình

                 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

— H.PWiz
nguồn

1

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

Hãy thử trực tuyến!

Lấy đầu vào là chuỗi

— gậy
nguồn

1

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

Hãy thử trực tuyến!

Chủ yếu là một cổng lặp của câu trả lời JavaScript của Arnauld , vì vậy hãy nâng cấp anh ấy!

— Olivier Grégoire
nguồn

0

Thạch , 23 byte

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

Hãy thử trực tuyến!

— Erik là người vượt trội
nguồn

0

J , 50 byte

định nghĩa hàm kiểu ngầm

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

nếu đối số (giả sử 63) được dán vào biểu thức REPL thì có thể là 45 ví dụ

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

,&1 nối 1 để tạo chuỗi tìm kiếm cũng như chuỗi đối số
^:(<453)"0 lặp lại mỗi lần cho đến khi đạt được 1mio theo trình tự 1 giây
+ [: */@(*#]) (#~10)&#: ngã ba thêm vào móc mà sản phẩm của các chữ số
(e.~ # ])/ sử dụng mục lặp lại nếu tồn tại để có giao điểm của danh sách
{. chỉ trả về giá trị chung đầu tiên

Hãy thử trực tuyến!

— jayprich
nguồn

0

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

phiên bản trước 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

— jayprich
nguồn

Chuỗi sản phẩm chữ số

Các thách thức

Quy tắc

JavaScript (ES6), 81 67 byte

Đã bình luận

Thạch , 18 14 byte

Làm thế nào nó hoạt động

Python 2 , 111 95 93 byte

Haskell , 65 byte

Python 2 , 78 byte

Husk , 13 byte

Giải trình

Python 3 , 126 125 byte

Java (JDK 10) , 99 byte

Thạch , 23 byte

J , 50 byte

R , 110 86 byte