甲贝尔数（OEIS A000110）是方式来划分一组n个标记的（不同）的元素数。第0个响铃编号定义为1。

让我们看一些示例（我使用方括号表示分区的子集和大括号）：

1: {1}
2: {[1,2]}, {[1],[2]}
3: {[1,2,3]}, {[1,2],[3]}, {[1,3],[2]}, {[2,3],[1]}, {[1],[2],[3]}

有多种计算贝尔编号的方法，您可以自由使用其中任何一种。这里将描述一种方法：

计算贝尔数的最简单方法是对二项式系数使用类似于Pascal三角形的数字三角形。钟形数字出现在三角形的边缘。从1开始，通过将上一行的最后一个条目作为第一个条目，然后将每个新条目设置为其左邻居加上左上邻居，来构造三角形中的每个新行：

1
1    2
2    3    5
5    7   10   15
15  20   27   37   52

您可以使用0索引或1索引。如果使用0索引，则输入3应该为输出5，但是2如果使用1索引，则应该输出。

您的程序必须输出15号铃号1382958545。从理论上讲，您的程序应该能够处理更大的数字（换句话说，不要对解决方案进行硬编码）。 编辑：您不需要处理输入0（对于0索引）或1（对于1索引），因为它不是由三角方法计算的。

测试用例（假设索引为0）：

0 ->  1 (OPTIONAL)
1 ->  1 
2 ->  2 
3 ->  5 
4 ->  15 
5 ->  52 
6 ->  203 
7 ->  877 
8 ->  4140 
9 ->  21147 
10 -> 115975 
11 -> 678570 
12 -> 4213597 
13 -> 27644437 
14 -> 190899322 
15 -> 1382958545

使用内置方法（例如Wolfram语言中的BellB [n]）直接产生响铃编号的答案将失去竞争力。

最短的代码（以字节为单位）获胜。

果冻，9字节

ṖµṀcæ.߀‘

这使用公式

当n <2时关闭。

在线尝试！

怎么运行的

ṖµṀcæ.߀‘  Main link. Argument: n

Ṗ          Pop; yield A := [1, ..., n-1].
 µ         Begin a new, monadic chain with argument A.
  Ṁ        Maximum; yield n-1.
   c       Combinatons; compute (n-1)C(k) for each k in A.
      ߀   Recursively map the main link over A.
    æ.     Take the dot product of the results to both sides.
        ‘  Increment; add 1 to the result.

JavaScript（ES6），47个字节

f=(n,a=[b=1])=>n--?f(n,[b,...a.map(e=>b+=e)]):b
f=(n,a=[b=1])=>--n?f(n,[b,...a.map(e=>b+=e)]):b

第一个是0索引，第二个是1索引。

Haskell，36个字节

head.(iterate(last>>=scanl(+))[1]!!)

使用三角形方法，正确处理基于0的0。

R，31个字节

sum(gmp::Stirling2.all(scan()))

使用第二类公式的斯特林数并用gmp软件包计算这些数; 从stdin读取并将值作为Big Integer返回；失败为0; 1个索引。

Mathematica，24个字节

Sum[k^#/k!,{k,0,∞}]/E&

@Kelly Lowder的-13个字节！

果冻，14 12 11字节

ṫ0;⁸+\
1Ç¡Ḣ

在线尝试！

并没有动态地输入¡ Jelly的强项，Ṫ总是修改数组并且缺少前置原子（一个字节;@或反向ṭ）。

CJam（19个字节）

Xa{X\{X+:X}%+}qi*0=

在线演示

解剖

Xa         e# Start with an array [1]
{          e# Repeat...
  X\       e#   Put a copy of X under the current row
  {X+:X}%  e#   Map over x in row: push (X+=x)
  +        e#   Prepend that copy of last element of the previous row to get the next row
}
qi*        e# ... input() times
0=         e# Select the first element

MATL，14字节

:dtEw1Zh1Ze/Yo

输入从0开始。在线尝试！

说明

这使用公式

其中_p F _q（a ₁，...，a _p ; b ₁，...，b _q ; x）是广义超几何函数。

:      % Implictly input n. Push array [1 2 ... n]
d      % Consecutive differences: array [1 ... 1] (n-1 entries)
tE     % Duplicate, multiply by 2: array [2 ... 2] (n-1 entries)
w      % Swap
1      % Push 1
Zh     % Hypergeometric function
1Ze    % Push number e
/      % Divide
Yo     % Round (to prevent numerical precision issues). Implicitly display

Python，42字节

f=lambda n,k=0:n<1or k*f(n-1,k)+f(n-1,k+1)

在线尝试！

递归公式来自将n元素放入分区中。对于每个元素，我们决定是否放置它：

• 进入现有分区，可以k选择
• 开始一个新分区，这增加了k将来元素的选择数量

两种方法都会减少n要放置的元素的剩余数量。因此，我们具有递归公式f(n,k)=k*f(n-1,k)+f(n-1,k+1)和f(0,k)=1，具有f(n,0)第n个Bell数。

Python 2，91字节

s=lambda n,k:n*k and k*s(n-1,k)+s(n-1,k-1)or n==k
B=lambda n:sum(s(n,k)for k in range(n+1))

在线尝试！

B（n）计算为第二种斯特林数的总和。

MATLAB，128103字节

function q(z)
r(1,1)=1;for x=2:z
r(x,1)=r(x-1,x-1);for y=2:x
r(x,y)=r(x,y-1)+r(x-1,y-1);end
end
r(z,z)

很自我解释。在行尾省略分号将打印结果。

Luis Mendo节省了25个字节。

R，46个字节

r=1;for(i in 1:scan())r=cumsum(c(r[i],r));r[1]

在线尝试！

MATL，19 18字节

1i:"t@q@:qXn*sh]0)

使用基于0的输入。基于递归关系

在线尝试！

欧姆，15个字节

2°M^┼ⁿ^!/Σ;αê/≈

在线尝试！

使用Dobinski的forumla（甚至适用于B（0）yay）。

说明

2°M^┼ⁿ^!/Σ;αê/≈
2°        ;     # Push 100
  M             # Do 100 times...
   ^             # Push index of current iteration
    ┼ⁿ           # Take that to the power of the user input
      ^!         # Push index factorial
        /        # Divide
         Σ       # Sum stack together
           αê   # Push e (2.718...)
             /  # Divide
              ≈ # Round to nearest integer (Srsly why doesn't 05AB1E have this???)

Python（79字节）

B=lambda n,r=[1]:n and B(n-1,[r[-1]+sum(r[:i])for i in range(len(r)+1)])or r[0]

使用Python 2的在线演示，但也可以在Python 3中使用。

这使用递归lambda构造高尔夫球循环来建立Aitken三角形。

Haskell，35个字节

(%0)
n%k|n<1=1|m<-n-1=k*m%k+m%(k+1)

在线尝试！

我的Python回答中说明了公式。

J，17个字节

0{]_1&({+/\@,])1:

使用三角形计算方法。

在线尝试！

说明

0{]_1&({+/\@,])1:  Input: integer n
               1:  The constant 1
  ]                Identity function, get n
   _1&(       )    Call this verb with a fixed left argument of -1 n times
                   on itself starting with a right argument [1]
             ]       Get right argument
       {             Select at index -1 (the last item)
            ,        Join
        +/\@         Find the cumulative sums
0{                 Select at index 0 (the first item)

Python 3，78个字节

from math import*
f=lambda n:ceil(sum(k**n/e/factorial(k)for k in range(2*n)))

我决定尝试另辟route径进行计算。这使用了0索引的Dobinski公式，不适用于0。

在线尝试！

Python 3中，68 60个字节

三角形的简单递归构造，但在实际应用中效率很低。计算最多15个贝尔号会导致TIO超时，但它在我的机器上有效。

这使用1索引，并返回True而不是1。

f=lambda r,c=0:r<1or c<1and f(r-1,r-1)or f(r-1,c-1)+f(r,c-1)

在线尝试！

感谢@FelipeNardiBatista节省了8个字节！

PHP，72字节

递归函数1索引

function f($r,$c=0){return$r?$c?f($r-1,$c-1)+f($r,$c-1):f($r-1,$r-2):1;}

在线尝试！

PHP，86字节

0索引

for(;$r++<$argn;)for($c=~0;++$c<$r;)$l=$t[$r][$c]=$c?$l+$t[$r-1][$c-1]:($l?:1);echo$l;

在线尝试！

PHP，89字节

递归函数0索引

function f($r,$s=NULL){$c=$s??$r-1;return$r>1?$c?f($r-1,$c-1)+f($r,$c-1):f($r-1,$r-2):1;}

在线尝试！

爱丽丝，22字节

/oi
\1@/t&wq]&w.q,+k2:

在线尝试！

这使用三角形方法。对于n = 0，它改为计算B（1），它方便地等于B（0）。

说明

这是程序的标准模板，这些程序在顺序模式下输入，在基本模式下进行处理，然后在顺序模式下输出结果。1已将A 添加到模板中，以将该值放在输入下方的堆栈中。

该程序使用堆栈作为扩展的圆形队列来计算三角形的每一行。在经过第一个迭代的每次迭代期间，堆栈下方的一个隐式零将变为显式零。

1     Append 1 to the implicit empty string on top of the stack
i     Get input n
t&w   Repeat outer loop that many times (push return address n-1 times)
q     Get tape position (initially zero)
]     Move right on tape
&w    On iteration k, push this return address k-1 times
      The following inner loop is run once for each entry in the next row
.     Duplicate top of stack (the last number calculated so far)
q,    Move the entry k spaces down to the top of the stack: this is the appropriate entry
      in the previous row, or (usually) an implicit zero if we're in the first column
+     Add these two numbers
k     Return to pushed address: this statement serves as the end of two loops simultaneously
2:    Divide by two: see below
o     Output as string
@     Terminate

尽管在堆栈顶部需要1，但第一次迭代有效地假定初始堆栈深度为零。结果，1最终被加到自己身上，并且整个三角形乘以2。将最终结果除以2得到正确的答案。

Pari / GP，36字节

n->n!*Vec(exp(exp(x+O(x^n++))-1))[n]

在线尝试！