Eine Bellsche Zahl ( OEIS A000110 ) ist die Anzahl von Möglichkeiten, eine Menge von n markierten (unterschiedlichen) Elementen zu partitionieren. Die 0. Bellsche Zahl ist als 1 definiert.

Schauen wir uns einige Beispiele an (ich verwende Klammern, um die Teilmengen und Klammern für die Partitionen zu bezeichnen):

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

Es gibt viele Möglichkeiten , Bellsche Zahlen zu berechnen, und Sie können jede davon verwenden. Ein Weg wird hier beschrieben:

Der einfachste Weg, Bellsche Zahlen zu berechnen, besteht darin, ein Zahlendreieck zu verwenden, das Pascals Dreieck für die Binomialkoeffizienten ähnelt. Die Glockennummern erscheinen an den Rändern des Dreiecks. Beginnend mit 1 wird jede neue Zeile im Dreieck erstellt, indem der letzte Eintrag in der vorherigen Zeile als erster Eintrag verwendet und dann jeder neue Eintrag auf seinen linken Nachbarn plus seinen oberen linken Nachbarn gesetzt wird:

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

Sie können 0-Indizierung oder 1-Indizierung verwenden. Wenn Sie die Indizierung 0 verwenden, sollte eine Eingabe von 3ausgegeben werden 5, sollte aber ausgegeben werden, 2wenn Sie die Indizierung 1 verwenden.

Ihr Programm muss bis zur 15. Bell-Nummer funktionieren und ausgeben 1382958545. Theoretisch sollte Ihr Programm in der Lage sein, größere Zahlen zu verarbeiten (mit anderen Worten, codieren Sie die Lösungen nicht hart). BEARBEITEN: Sie müssen keine Eingabe von 0 (für die 0-Indizierung) oder 1 (für die 1-Indizierung) verarbeiten, da diese nicht mit der Dreieck-Methode berechnet wird.

Testfälle (unter der Annahme einer 0-Indizierung):

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

Antworten mit einer integrierten Methode (wie BellB [n] in der Wolfram-Sprache), die direkt Bell-Zahlen erzeugt, sind nicht wettbewerbsfähig.

Kürzester Code (in Bytes) gewinnt.

Gelee , 9 Bytes

ṖµṀcæ.߀‘

Dies verwendet die Formel

welches geschlossen ist, wenn n <2 ist .

Probieren Sie es online!

Wie es funktioniert

ṖµṀ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 Byte

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

Ersteres ist 0-indiziert, zweiteres ist 1-indiziert.

Haskell, 36 Bytes

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

Verwendet die Dreieck-Methode und verarbeitet 0, 0-basiert korrekt.

R , 31 Bytes

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

verwendet die Stirling-Zahl der zweiten Art-Formel und berechnet diese Zahlen mit dem gmp-Paket ; liest aus stdin und gibt den Wert als Big Integer zurück; fehlgeschlagen für 0; 1-indiziert.

Mathematica, 24 Bytes

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

-13 Bytes von @Kelly Lowder!

Jelly , 14 12 11 Bytes

ṫ0;⁸+\
1Ç¡Ḣ

Probieren Sie es online!

Hat nicht gerade die Stärken von Jelly mit dynamischem Input getroffen ¡, Ṫ immer das Array zu modifizieren und das Fehlen eines vorangestellten Atoms (ein Byte ;@oder Reverse- ṭ).

CJam (19 Bytes)

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

Online-Demo

Präparation

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 Bytes

:dtEw1Zh1Ze/Yo

Die Eingabe ist 0-basiert. Probieren Sie es online!

Erläuterung

Dies verwendet die Formel

wobei _p F _q ( a ₁ , ..., a _p ; b ₁ , ..., b _q ; x ) die verallgemeinerte hypergeometrische Funktion ist .

:      % 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 Bytes

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

Probieren Sie es online!

Die rekursive Formel stammt aus dem Platzieren von nElementen in Partitionen. Für jedes Element entscheiden wir, ob es platziert werden soll:

• In eine vorhandene Partition, von der es kAuswahlmöglichkeiten gibt
• So starten Sie eine neue Partition, die die Anzahl der Auswahlmöglichkeiten kfür zukünftige Elemente erhöht

In beiden Fällen wird die verbleibende Anzahl nder zu platzierenden Elemente verringert . Wir haben also die rekursive Formel f(n,k)=k*f(n-1,k)+f(n-1,k+1)und f(0,k)=1mit f(n,0)der n-ten Bell-Zahl.

Python 2 , 91 Bytes

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

Probieren Sie es online!

B (n) berechnet als Summe von Stirlingzahlen der zweiten Art.

MATLAB, 128 103 Bytes

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)

Ziemlich selbsterklärend. Das Auslassen eines Semikolons am Ende einer Zeile gibt das Ergebnis aus.

25 Bytes gespart dank Luis Mendo.

R , 46 Bytes

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

Probieren Sie es online!

MATL , 19 18 Bytes

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

Verwendet 0-basierte Eingabe. Basierend auf der Wiederholungsrelation

Probieren Sie es online!

Ohm , 15 Bytes

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

Probieren Sie es online!

Benutzt Dobinskis Forum (funktioniert sogar für B (0) yay ).

Erläuterung

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

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]

Online-Demo in Python 2, aber es funktioniert auch in Python 3.

Auf diese Weise wird das Aitken-Dreieck mit einem rekursiven Lambda für eine Golfschleife erstellt.

Haskell , 35 Bytes

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

Probieren Sie es online!

Formel erklärt in meiner Python-Antwort .

J, 17 Bytes

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

Verwendet die Dreiecksberechnungsmethode.

Probieren Sie es online!

Erläuterung

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 Bytes

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

Ich beschloss, eine andere Route für die Berechnung zu versuchen. Dies verwendet Dobinskis Formel, 0-indiziert, funktioniert nicht für 0.

Probieren Sie es online!

Python 3 , 68 60 Bytes

Einfache rekursive Konstruktion des Dreiecks, aber aus praktischen Gründen ineffizient. Wenn Sie bis zur 15. Bell-Zahl rechnen, tritt eine Zeitüberschreitung bei TIO auf, die jedoch auf meinem Computer funktioniert.

Dies verwendet die 1-Indizierung und gibt Truestatt 1 zurück.

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

Probieren Sie es online!

Vielen Dank an @FelipeNardiBatista für das Speichern von 8 Bytes!

PHP , 72 Bytes

rekursive Funktion 1-indiziert

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

Probieren Sie es online!

PHP , 86 Bytes

0-indiziert

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

Probieren Sie es online!

PHP , 89 Bytes

rekursive Funktion 0-indiziert

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

Probieren Sie es online!

Alice , 22 Bytes

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

Probieren Sie es online!

Dies verwendet die Dreiecksmethode. Für n = 0 wird stattdessen B (1) berechnet, was günstigerweise gleich B (0) ist.

Erläuterung

Dies ist eine Standardvorlage für Programme, die Eingaben im Ordinalmodus verarbeiten und das Ergebnis im Ordinalmodus ausgeben. 1Der Vorlage wurde ein A hinzugefügt, um diesen Wert auf dem Stapel unter der Eingabe abzulegen.

Das Programm verwendet den Stapel als expandierende kreisförmige Warteschlange, um jede Zeile des Dreiecks zu berechnen. Während jeder Iteration nach der ersten wird eine implizite Null unter dem Stapel zu einer expliziten Null.

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

Die erste Iteration geht effektiv von einer anfänglichen Stapeltiefe von Null aus, trotz der erforderlichen 1 oben im Stapel. Infolgedessen wird die 1 zu sich selbst addiert, und das gesamte Dreieck wird mit 2 multipliziert. Wenn Sie das Endergebnis durch 2 dividieren, erhalten Sie die richtige Antwort.

Pari / GP , 36 Bytes

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

Probieren Sie es online!