Sylvester的序列OEIS A000058是一个整数序列，定义如下：

每个成员是所有先前成员加一的乘积。序列的第一个成员是2。

任务

创建可能的最小程序，该程序需要n并计算Sylvester序列的第n个项。标准输入，输出和漏洞适用。由于结果增长很快，因此您不希望接受任何会导致选择语言溢出的术语。

测试用例

您可以使用零个或一个索引。（这里我使用零索引）

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

Brain-Flak，76 68 58 52 46字节

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

在线尝试！

改用以下关系：

它是根据从序列中提供的关系修改后的这种关系得出的：

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

说明

有关每个命令的功能的文档，请访问GitHub页面。

Brain-Flak中有两个堆栈，我将分别命名为堆栈1和堆栈2。

输入存储在堆栈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.

对于生成算法：

({({}[()])({})}{}())      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).

备用46字节版本

这仅使用一个堆栈。

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

在线尝试！

果冻，5 个字节

Ḷ߀P‘

这使用基于0的索引和质询规范的定义。

在线尝试！或验证所有测试用例。

怎么运行的

Ḷ߀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.

六边形，27字节

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

展开：

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

在线尝试！

说明

让我们考虑一下顺序b(a) = a(n) - 1并进行一些重新排列：

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)

这个序列非常相似，但是我们可以将增量推迟到最后，这恰好在该程序中节省了一个字节。

因此，这是带注释的源代码：

^{用Timwi的HexagonyColorer创建。}

这是一个内存图（红色三角形显示内存指针的初始位置和方向）：

^{用Timwi的EsotericIDE创建。}

代码从环绕左角的灰色路径开始，因此初始线性位如下：

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

然后，代码到达<分支的，并指示主循环的开始（和结束）。只要N边具有正值，就会执行绿色路径。该路径在网格周围缠绕了几次，但实际上是完全线性的：

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

的.是空操作，所以实际的代码是：

""~&}=*}=+={(
""             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.

一旦此减量减少N到0，就会执行红色路径：

")!@
"     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字节

这个版本感谢randomra。稍后，我将尝试写详细的说明。

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

J，14个字节

这个版本感谢哩。使用大副词^:代替议程，如下所示。会有更多解释。

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

J，18个字节

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

0索引。

例子

   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

说明

这是一个看起来像这样的议程：

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

（(9!:7)'┌┬┐├┼┤└┴┘│─'然后使用生成5!:4<'e'）

分解：

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

使用顶部的分支作为gerund G，底部的作为选择器F，这是：

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

这在2:时0 = * n，即在符号为零（因此n为零）时使用常数函数。否则，我们使用此fork：

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

这是其中之一，再加上以下顶级系列：

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

进一步分解，这是范围（*/）上自参考（$:）的乘积（i.）。

Perl 6，24个字节

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

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

说明

# 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
  )[ $_ ]
}

用法：

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个字节

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

用法示例：f 4-> 1807。

Java 7，46 42字节

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

使用带有常规公式的0索引。不过我换n*n-n了n*(n-1)，因为Java没有方便的运算符，而且f()通话时间越来越长。

Haskell，25个字节

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

SILOS，60个字节

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

在线尝试！

我在C中答案的端口。

Brain-Flak，158154字节

漏尼姑让我在这里打败

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

在线尝试！

说明

在输入a（0）下放置两个

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

当输入大于零时，从输入中减去1并...

{
({}[()]

默默...

<

将一个放在另一个堆栈上以充当乘法<>（（））<>

当堆栈为非空时

 ([])
 {
  {}

将列表顶部移至上方并复制

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

将催化剂乘以副本

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

加一

 <>({}())

将序列移回正确的堆栈

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

除去底部的所有内容（即最后创建的数字）

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

C，32个字节

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

使用基于1的索引。在Ideone上进行测试。

实际上，9个字节

2@`rΣτu`n

在线尝试！

改用以下关系：

它是根据从序列中提供的关系修改后的这种关系得出的：

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

R，44 42 41字节

多亏了JDL，节省了2个字节

多亏了user5957401，节省了1个字节

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

Oasis，4字节（无竞争）

可能是我打高尔夫球的最后一门语言！不竞争，因为该语言将挑战推迟了。

码：

²->2

感谢Zwei的替代解决方案：

<*>2

扩展版本：

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

说明：

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

使用CP-1252编码。在线尝试！

Python，38 36字节

2个字节感谢Dennis。

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

伊迪恩！

使用从序列中提供的关系修改的此关系：

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

说明

0**n*22何时n=0以及0其他情况下返回，因为0**0定义为1在Python中。

Cheddar，26个字节

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

在线尝试！

很习惯。

说明

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个字节

2{_(*)}ri*

使用基于0的索引。在线尝试！

05AB1E，7个字节

2sFD<*>

讲解

使用基于零的索引。

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

在线尝试！

Prolog，49个字节

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

SILOS 201字节

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

随时在线尝试！

果冻，7个字节

²_’
2Ç¡

在线尝试！

而是使用序列中提供的此关系： a(n+1) = a(n)^2 - a(n) + 1

说明

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字节

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

伊迪恩！

使用p作为产品的临时存储。

基本上，我定义了两个序列p(n)和r(n)，其中r(n)=p(n-1)+1和p(n)=p(n-1)*r(n)。

r(n) 是必需的序列。

R，50 46 44字节

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

我们不跟踪整个序列，而只是跟踪乘积，只要n> 1 n> 0 ，就遵循给定的二次更新规则。（这个顺序使用“开始于一个零”惯例）

使用从零开始的约定可以节省几个字节，因为我们可以使用if（n）而不是if（n> 1）

水母，13字节

p
\Ai
&(*
><2

在线尝试！

说明

让我们从头开始：

(*
<

这是一个钩子，定义了一个功能f(x) = (x-1)*x。

&(*
><

这用增量函数组成了前面的钩子，因此给我们一个函数g(x) = (x-1)*x+1。

\Ai
&(*
><

最后，这将生成一个函数，该函数h是前一个函数的迭代，g是整数输入给定的次数。

\Ai
&(*
><2

最后，我们将此迭代应用于初始值2。在p顶部只是打印结果。

备用（也是13个字节）

p
>
\Ai
(*
>1

这将增量推迟到最后。

C，43，34，33个字节

1索引：

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

测试主体：

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个字节

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

在线尝试！

改用以下关系：

它是根据从序列中提供的关系修改后的这种关系得出的：

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

Mathematica，19个字节

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

或21个字节：

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

迷宫，18字节

归功于Sp3000，他们独立发现了相同的解决方案。

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

在线尝试！

实际上，14 12个字节

这使用了0索引。欢迎打高尔夫球。在线尝试！

2#,`;πu@o`nF

开球：

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字节

2个字节感谢Dennis。

~2\{.(*)}*

在线尝试！

用途a(n) = a(n-1) * (a(n-1)-1) + 1。