Trình tự của Sylvester, OEIS A000058 , là một chuỗi số nguyên được định nghĩa như sau:

Mỗi thành viên là sản phẩm của tất cả các thành viên trước đó cộng với một. Thành viên đầu tiên của chuỗi là 2.

Bài tập

Tạo chương trình nhỏ nhất có thể có n và tính toán số thứ n của Chuỗi Sylvester. Tiêu chuẩn đầu vào, đầu ra và sơ hở áp dụng. Vì kết quả phát triển rất nhanh, bạn không cần phải thực hiện bất kỳ thuật ngữ nào trong đó kết quả sẽ gây ra tràn trong ngôn ngữ bạn đã chọn.

Các trường hợp thử nghiệm

Bạn có thể sử dụng 0 hoặc một chỉ mục. (Ở đây tôi sử dụng lập chỉ mục bằng 0)

>>0
2
>>1
3
>>2
7
>>3
43
>>4
1807

Brain-Flak , 76 68 58 52 46 byte

<>(()())<>{({}[()])<>({({}[()])({})}{}())<>}<>

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

Sử dụng mối quan hệ này thay thế:

bắt nguồn từ mối quan hệ này được sửa đổi từ mối quan hệ được cung cấp trong chuỗi:

a(n+1) = a(n) * (a(n) - 1) + 1.

Giải trình

Để biết tài liệu về những gì mỗi lệnh thực hiện, vui lòng truy cập trang GitHub .

Có hai ngăn xếp trong Brain-Flak, mà tôi sẽ đặt tên lần lượt là Stack 1 và Stack 2.

Đầu vào được lưu trữ trong Stack 1.

<>(()())<>             Store 2 in Stack 2.

{                      while(Stack_1 != 0){
  ({}[()])                 Stack_1 <- Stack_1 - 1;
  <>                       Switch stack.
  ({({}[()])({})}{}())     Generate the next number in Stack 2.
  <>                       Switch back to Stack 1.
}

<>                     Switch to Stack 2, implicitly print.

Đối với thuật toán tạo:

({({}[()])({})}{}())      Top <- (Top + Top + (Top-1) + (Top-1) + ... + 0) + 1

(                  )      Push the sum of the numbers evaluated in the process:

 {            }               while(Top != 0){
  ({}[()])                        Pop Top, push Top-1    (added to sum)
          ({})                    Pop again, push again  (added to sum)
                              }

               {}             Top of stack is now zero, pop it.
                 ()           Evaluates to 1 (added to sum).

Phiên bản 46 byte thay thế

Điều này chỉ sử dụng một ngăn xếp.

({}<(()())>){({}<({({}[()])({})}{}())>[()])}{}

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

Thạch , 5 byte

Ḷ߀P‘

Điều này sử dụng lập chỉ mục dựa trên 0 và định nghĩa từ thông số kỹ thuật thách thức.

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

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

Ḷ߀P‘  Main link. Argument: n

Ḷ      Unlength; yield [0, ..., n - 1].
 ߀    Recursively apply the main link to each integer in that range.
   P   Take the product. This yields 1 for an empty range.
    ‘  Increment.

Lục giác , 27 byte

1{?)=}&~".>")!@(</=+={"/>}*

Mở ra:

    1 { ? )
   = } & ~ "
  . > " ) ! @
 ( < / = + = {
  " / > } * .
   . . . . .
    . . . .

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

Giải trình

Hãy xem xét trình tự b(a) = a(n) - 1và sắp xếp lại một chút:

b(a) = a(n) - 1
     = a(n-1)*(a(n-1)-1) + 1 - 1
     = (b(n-1) + 1)*(b(n-1) + 1 - 1)
     = (b(n-1) + 1)*b(n-1)
     = b(n-1)^2 + b(n-1)

Trình tự này rất giống nhau nhưng chúng ta có thể trì hoãn gia số đến cuối, điều này xảy ra để lưu một byte trong chương trình này.

Vì vậy, đây là mã nguồn chú thích:

^{Được tạo bằng HexagonyColorer của Timwi's .}

Và đây là sơ đồ bộ nhớ (hình tam giác màu đỏ hiển thị vị trí và hướng ban đầu của con trỏ bộ nhớ):

^{Được tạo ra với Timoti's EsotericIDE .}

Mã bắt đầu trên đường dẫn màu xám bao bọc góc bên trái, vì vậy bit tuyến tính ban đầu là như sau:

1{?)(
1      Set edge b(1) to 1.
 {     Move MP to edge N.
  ?    Read input into edge N.
   )(  Increment, decrement (no-op).

Sau đó, mã chạm vào <đó là một nhánh và cho biết bắt đầu (và kết thúc) của vòng lặp chính. Miễn là cạnh N có giá trị dương, đường dẫn màu xanh lá cây sẽ được thực thi. Đường dẫn đó quấn quanh lưới một vài lần, nhưng thực ra nó hoàn toàn tuyến tính:

""~&}=.*}=+={....(

Không .có ops, vì vậy mã thực tế là:

""~&}=*}=+={(
""             Move the MP to edge "copy".
  ~            Negate. This is to ensure that the value is negative so that &...
   &           ...copies the left-hand neighbour, i.e. b(i).
    }=         Move the MP to edge b(i)^2 and turn it around.
      *        Multiply the two copies of b(i) to compute b(i)^2.
       }=      Move the MP back to edge b(i) and turn it around.
         +     Add the values in edges "copy" and b(i)^2 to compute
               b(i) + b(i)^2 = b(i+1).
          ={   Turn the memory pointer around and move to edge N.
            (  Decrement.

Khi decrementing điều này làm giảm Ntới 0, con đường đỏ được thực hiện:

")!@
"     Move MP back to edge b(i) (which now holds b(N)).
 )    Increment to get a(N).
  !   Print as integer.
   @  Terminate the program.

J, 18 14 12 byte

Phiên bản này nhờ vào Randomra. Tôi sẽ cố gắng viết một lời giải thích chi tiết sau.

0&(]*:-<:)2:

J, 14 byte

Phiên bản này nhờ dặm. Đã sử dụng trạng từ sức mạnh ^:thay vì một chương trình nghị sự như dưới đây. Thêm lời giải thích sắp tới.

2(]*:-<:)^:[~]

J, 18 byte

2:`(1+*/@$:@i.)@.*

Chỉ số 0.

Ví dụ

   e =: 2:`(1+*/@$:@i.)@.*
   e 1
3
   e 2
7
   e 3
43
   e 4
1807
   x: e i. 10
2 3 7 43 1807 3263443 10650056950807 113423713055421862298779648 12864938683278674737956996400574416174101565840293888 1655066473245199944217466828172807675196959605278049661438916426914992848    91480678309535880456026315554816
   |: ,: x: e i. 10
                                                                                                        2
                                                                                                        3
                                                                                                        7
                                                                                                       43
                                                                                                     1807
                                                                                                  3263443
                                                                                           10650056950807
                                                                              113423713055421862298779648
                                                    12864938683278674737956996400574416174101565840293888
165506647324519994421746682817280767519695960527804966143891642691499284891480678309535880456026315554816

Giải trình

Đây là một chương trình nghị sự giống như thế này:

           ┌─ 2:
           │    ┌─ 1
       ┌───┤    ├─ +
       │   └────┤           ┌─ / ─── *
── @. ─┤        │     ┌─ @ ─┴─ $:
       │        └─ @ ─┴─ i.
       └─ *

(Được tạo bằng cách sử dụng (9!:7)'┌┬┐├┼┤└┴┘│─'sau đó 5!:4<'e')

Đang phân hủy:

       ┌─ ...
       │
── @. ─┤
       │
       └─ *

Sử dụng nhánh trên cùng làm gerund Gvà dưới cùng là bộ chọn F, đây là:

e n     <=>     ((F n) { G) n

Điều này sử dụng hàm hằng 2:khi 0 = * n, nghĩa là khi dấu bằng 0 (do đó nbằng 0). Mặt khác, chúng tôi sử dụng ngã ba này:

  ┌─ 1
  ├─ +
──┤           ┌─ / ─── *
  │     ┌─ @ ─┴─ $:
  └─ @ ─┴─ i.

Đó là một trong những chuỗi trên cùng sau đây:

            ┌─ / ─── *
      ┌─ @ ─┴─ $:
── @ ─┴─ i.

Phân tách hơn nữa, đây là sản phẩm ( */) trên tự tham chiếu ( $:) trên phạm vi ( i.).

Perl 6 , 24 byte

{(2,{1+[*] @_}...*)[$_]}

{(2,{1+.²-$_}...*)[$_]}

Giải trình

# bare block with implicit parameter ｢$_｣
{
  (
    # You can replace 2 with 1 here
    # so that it uses 1 based indexing
    # rather than 0 based
    2,

    # bare block with implicit parameter ｢@_｣
    {
      1 +

      # reduce the input of this inner block with ｢&infix:<*>｣
      # ( the input is all of them generated when using a slurpy @ var )
      [*] @_

      # that is the same as:
      # ｢@_.reduce: &infix:<*>｣
    }

    # keep calling that to generate more values until:
    ...

    # forever
    *

  # get the value as indexed by the input
  )[ $_ ]
}

Sử dụng:

my &code = {(2,{1+[*] @_}...*)[$_]}

say code 0; # 2
say code 1; # 3
say code 2; # 7
say code 3; # 43
say code 4; # 1807

# you can even give it a range
say code 4..7;
# (1807 3263443 10650056950807 113423713055421844361000443)

say code 8;
# 12864938683278671740537145998360961546653259485195807
say code 9;
# 165506647324519964198468195444439180017513152706377497841851388766535868639572406808911988131737645185443
say code 10;
# 27392450308603031423410234291674686281194364367580914627947367941608692026226993634332118404582438634929548737283992369758487974306317730580753883429460344956410077034761330476016739454649828385541500213920807

my $start = now;
# how many digits are there in the 20th value
say chars code 20;
# 213441

my $finish = now;
# how long did it take to generate the values up to 20
say $finish - $start, ' seconds';
# 49.7069076 seconds

Haskell, 26 byte

f n|n<1=2|m<-f$n-1=1+m*m-m

Ví dụ sử dụng: f 4-> 1807.

Java 7, 46 42 byte

int f(int n){return--n<0?2:f(n)*~-f(n)+1;}

Sử dụng chỉ mục 0 với công thức thông thường. Tôi hoán đổi n*n-ncho n*(n-1)dù, vì Java không có một nhà điều hành điện tiện dụng, và các f()cuộc gọi được nhận từ lâu.

Haskell, 25 byte

(iterate(\m->m*m-m+1)2!!)

Silos , 60 byte

readIO 
p = 2
lblL
r = p
r + 1
p * r
i - 1
if i L
printInt r

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

Cảng câu trả lời của tôi trong C .

Brain-Flak , 158 154 byte

Leaky Nun đã đánh bại tôi ở đây

({}<(()())>){({}[()]<<>(())<>([]){{}<>({}<<>(({}<>))><>)<>({<({}[()])><>({})<>}{})<>{}([])}{}<>({}())([]){{}({}<>)<>([])}{}<>>)}{}([][()]){{}{}([][()])}{} 

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

Giải trình

Đặt hai dưới đầu vào a (0)

({}<(()())>) 

Trong khi đầu vào lớn hơn 0 trừ đi một đầu vào và ...

{
({}[()]

Thầm lặng...

<

Đặt một cái vào ngăn xếp khác để làm chất xúc tác cho phép nhân <> (()) <>

Trong khi ngăn xếp không trống

 ([])
 {
  {}

Di chuyển đầu danh sách và sao chép

  <>({}<<>(({}<>))><>)

Nhân chất xúc tác với bản sao

  <>({<({}[()])><>({})<>}{})<>{}
  ([])
 }
 {}

Cộng một

 <>({}())

Di chuyển trình tự trở lại ngăn xếp thích hợp

 ([])
 {
 {}
 ({}<>)<>
 ([])
 }
 {}
 <>
>)
}{}

Xóa tất cả trừ mục dưới cùng (tức là số cuối cùng được tạo)

([][()])
{
{}
{}
([][()])
}
{}

C, 32 byte

f(n){return--n?f(n)*~-f(n)+1:2;}

Sử dụng lập chỉ mục 1 dựa trên. Kiểm tra nó trên Ideone .

Trên thực tế , 9 byte

2@`rΣτu`n

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

Sử dụng mối quan hệ này thay thế:

bắt nguồn từ mối quan hệ này được sửa đổi từ mối quan hệ được cung cấp trong chuỗi:

a(n+1) = a(n) * (a(n) - 1) + 1.

R, 44 42 41 byte

Tiết kiệm 2 byte nhờ JDL

Tiết kiệm 1 byte nhờ user5957401

f=function(n)ifelse(n,(a=f(n-1))^2-a+1,2)

Ốc đảo , 4 byte (không cạnh tranh)

Có lẽ ngôn ngữ cuối cùng của tôi từ gia đình chơi golf! Không cạnh tranh, vì ngôn ngữ hoãn thách thức.

Mã số:

²->2

Giải pháp thay thế nhờ Zwei :

<*>2

Phiên bản mở rộng:

a(n) = ²->
a(0) = 2

Giải trình:

²    # Stack is empty, so calculate a(n - 1) ** 2.
 -   # Subtract, arity 2, so use a(n - 1).
  >  # Increment by 1.

Sử dụng mã hóa CP-1252 . Hãy thử trực tuyến!

Con trăn, 38 36 byte

2 byte nhờ Dennis.

f=lambda n:0**n*2or~-f(n-1)*f(n-1)+1

Nghĩa là nó!

Thay vào đó, sử dụng mối quan hệ này được sửa đổi từ mối quan hệ được cung cấp trong chuỗi:

a(n+1) = a(n) * (a(n) - 1) + 1

Giải trình

0**n*2trả về 2khi n=0và 0nếu không, bởi vì 0**0được định nghĩa là 1trong Python.

Cheddar , 26 byte

n g->n?g(n-=1)**2-g(n)+1:2

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

Khá thành ngữ.

Giải trình

n g ->    // Input n, g is this function
  n ?     // if n is > 1
    g(n-=1)**2-g(n)+1   // Do equation specified in OEIS
  : 2     // if n == 0 return 2

CJam, 10 byte

2{_(*)}ri*

Sử dụng lập chỉ mục dựa trên 0. Hãy thử trực tuyến!

05AB1E , 7 byte

2sFD<*>

Giải thích

Sử dụng lập chỉ mục dựa trên không.

2         # push 2 (initialization for n=0)
 sF       # input nr of times do
   D<*    # x(x-1)
      >   # add 1

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

Prolog, 49 byte

a(0,2).
a(N,R):-N>0,M is N-1,a(M,T),R is T*T-T+1.

SILOS 201 byte

readIO 
def : lbl
set 128 2
set 129 3
j = i
if j z
print 2
GOTO e
:z
j - 1
if j Z
print 3
GOTO e
:Z
i - 1
:a
a = 127
b = 1
c = 1
:b
b * c
a + 1
c = get a
if c b
b + 1
set a b
i - 1
if i a
printInt b
:e

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

Thạch , 7 byte

²_’
2Ç¡

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

Sử dụng mối quan hệ này được cung cấp trong chuỗi thay thế: a(n+1) = a(n)^2 - a(n) + 1

Giải trình

2Ç¡   Main chain, argument in input

2     Start with 2
  ¡   Repeat as many times as the input:
 Ç        the helper link.


²_’   Helper link, argument: z
²     z²
  ’   z - 1
 _    subtraction, yielding z² - (z-1) = z² - z + 1

C, 46 byte

s(n,p,r){for(p=r=2;n-->0;p*=r)r=p+1;return r;}

Nghĩa là nó!

Sử dụng pnhư là lưu trữ tạm thời của sản phẩm.

Về cơ bản, tôi đã xác định hai chuỗi p(n)và r(n), ở đâu r(n)=p(n-1)+1và p(n)=p(n-1)*r(n).

r(n) là trình tự cần thiết.

R, 50 46 44 byte

    n=scan();v=2;if(n)for(i in 1:n){v=v^2-v+1};v

Thay vì theo dõi toàn bộ chuỗi, chúng tôi chỉ theo dõi sản phẩm, tuân theo quy tắc cập nhật bậc hai đã cho miễn là n> 1 n> 0. (Trình tự này sử dụng quy ước "bắt đầu từ một không")

Sử dụng quy ước bắt đầu bằng 0 sẽ tiết kiệm được một vài byte vì chúng ta có thể sử dụng if (n) thay vì if (n> 1)

Sứa , 13 byte

p
\Ai
&(*
><2

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

Giải trình

Hãy bắt đầu từ dưới lên:

(*
<

Đây là một cái móc, định nghĩa một chức năng f(x) = (x-1)*x.

&(*
><

Cái này kết hợp hook trước với hàm tăng để nó cung cấp cho chúng ta hàm g(x) = (x-1)*x+1.

\Ai
&(*
><

Cuối cùng, điều này tạo ra một hàm hlà một lần lặp của hàm trước đó g, nhiều lần như được đưa ra bởi đầu vào số nguyên.

\Ai
&(*
><2

Và cuối cùng, chúng tôi áp dụng phép lặp này cho giá trị ban đầu 2 . Ở pđầu chỉ in kết quả.

Thay thế (cũng 13 byte)

p
>
\Ai
(*
>1

Điều này trì hoãn sự gia tăng cho đến cuối cùng.

C, 43 , 34 , 33 byte

1 chỉ mục:

F(n){return--n?n=F(n),n*n-n+1:2;}

Kiểm tra chính:

int main() {
  printf("%d\n", F(1));
  printf("%d\n", F(2));
  printf("%d\n", F(3));
  printf("%d\n", F(4));
  printf("%d\n", F(5));
}

Brachylog , 13 byte

0,2|-:0&-y+*+

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

Sử dụng mối quan hệ này thay thế:

bắt nguồn từ mối quan hệ này được sửa đổi từ mối quan hệ được cung cấp trong chuỗi:

a(n+1) = a(n) * (a(n) - 1) + 1.

Toán học, 19 byte

Nest[#^2-#+1&,2,#]&

Hoặc 21 byte:

Array[#0,#,0,1+1##&]&

Mê cung , 18 byte

Tín dụng cho Sp3000 người tìm thấy giải pháp tương tự một cách độc lập.

?
#
)}"{!@
* (
(:{

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

Trên thực tế , 14 12 byte

Điều này được sử dụng chỉ mục 0. Gợi ý chơi golf chào mừng. Hãy thử trực tuyến!

2#,`;πu@o`nF

Ungolfing:

2#              Start with [2]
  ,`     `n     Take 0-indexed input and run function (input) times
    ;           Duplicate list
     πu         Take product of list and increment
       @o       Swap and append result to the beginning of the list
           F    Return the first item of the resulting list

GolfScript , 12 10 byte

2 byte nhờ Dennis.

~2\{.(*)}*

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

Công dụng a(n) = a(n-1) * (a(n-1)-1) + 1.