Bernoulli-Zahlen

23

Die Bernoulli-Zahlen (insbesondere die zweiten Bernoulli-Zahlen) werden durch die folgende rekursive Definition definiert:

zweite Bernoulli-Zahlen

Wobei mCkeine Kombination bezeichnet .

Geben Sie bei einer nichtnegativen Ganzzahl mals Eingabe die Dezimaldarstellung ODER einen reduzierten Bruch für die mzweite Bernoulli-Zahl aus. Wenn Sie eine Dezimaldarstellung ausgeben, müssen Sie eine Genauigkeit von mindestens 6 Dezimalstellen (Nachkommastellen) haben und auf 6 Dezimalstellen gerundet genau sein. Zum Beispiel für m = 2, 0.166666523akzeptabel ist , weil es rundet auf 0.166667. 0.166666389ist nicht akzeptabel, weil es auf rundet 0.166666. Nachgestellte Nullen können weggelassen werden. Für Dezimaldarstellungen kann die wissenschaftliche Notation verwendet werden.

Hier ist die Eingabe und die erwartete Ausgabe für mbis zu einschließlich 60, in wissenschaftlicher Notation auf 6 Dezimalstellen gerundet und als reduzierte Brüche:

0 -> 1.000000e+00 (1/1)
1 -> 5.000000e-01 (1/2)
2 -> 1.666667e-01 (1/6)
3 -> 0.000000e+00 (0/1)
4 -> -3.333333e-02 (-1/30)
5 -> 0.000000e+00 (0/1)
6 -> 2.380952e-02 (1/42)
7 -> 0.000000e+00 (0/1)
8 -> -3.333333e-02 (-1/30)
9 -> 0.000000e+00 (0/1)
10 -> 7.575758e-02 (5/66)
11 -> 0.000000e+00 (0/1)
12 -> -2.531136e-01 (-691/2730)
13 -> 0.000000e+00 (0/1)
14 -> 1.166667e+00 (7/6)
15 -> 0.000000e+00 (0/1)
16 -> -7.092157e+00 (-3617/510)
17 -> 0.000000e+00 (0/1)
18 -> 5.497118e+01 (43867/798)
19 -> 0.000000e+00 (0/1)
20 -> -5.291242e+02 (-174611/330)
21 -> 0.000000e+00 (0/1)
22 -> 6.192123e+03 (854513/138)
23 -> 0.000000e+00 (0/1)
24 -> -8.658025e+04 (-236364091/2730)
25 -> 0.000000e+00 (0/1)
26 -> 1.425517e+06 (8553103/6)
27 -> 0.000000e+00 (0/1)
28 -> -2.729823e+07 (-23749461029/870)
29 -> 0.000000e+00 (0/1)
30 -> 6.015809e+08 (8615841276005/14322)
31 -> 0.000000e+00 (0/1)
32 -> -1.511632e+10 (-7709321041217/510)
33 -> 0.000000e+00 (0/1)
34 -> 4.296146e+11 (2577687858367/6)
35 -> 0.000000e+00 (0/1)
36 -> -1.371166e+13 (-26315271553053477373/1919190)
37 -> 0.000000e+00 (0/1)
38 -> 4.883323e+14 (2929993913841559/6)
39 -> 0.000000e+00 (0/1)
40 -> -1.929658e+16 (-261082718496449122051/13530)
41 -> 0.000000e+00 (0/1)
42 -> 8.416930e+17 (1520097643918070802691/1806)
43 -> 0.000000e+00 (0/1)
44 -> -4.033807e+19 (-27833269579301024235023/690)
45 -> 0.000000e+00 (0/1)
46 -> 2.115075e+21 (596451111593912163277961/282)
47 -> 0.000000e+00 (0/1)
48 -> -1.208663e+23 (-5609403368997817686249127547/46410)
49 -> 0.000000e+00 (0/1)
50 -> 7.500867e+24 (495057205241079648212477525/66)
51 -> 0.000000e+00 (0/1)
52 -> -5.038778e+26 (-801165718135489957347924991853/1590)
53 -> 0.000000e+00 (0/1)
54 -> 3.652878e+28 (29149963634884862421418123812691/798)
55 -> 0.000000e+00 (0/1)
56 -> -2.849877e+30 (-2479392929313226753685415739663229/870)
57 -> 0.000000e+00 (0/1)
58 -> 2.386543e+32 (84483613348880041862046775994036021/354)
59 -> 0.000000e+00 (0/1)
60 -> -2.139995e+34 (-1215233140483755572040304994079820246041491/56786730)

Referenzimplementierung (in Python 3):

def factorial(n):
    if n < 1:
        return 1
    else:
        return n * factorial(n - 1)

def combination(m,k):
    if k <= m:
        return factorial(m)/(factorial(k) * factorial(m - k))
    else:
        return 0

def Bernoulli(m):
    if m == 0:
        return 1
    else:
        t = 0
        for k in range(0, m):
            t += combination(m, k) * Bernoulli(k) / (m - k + 1)
        return 1 - t

Regeln

  • Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes
  • Sie dürfen keine integrierten oder in einer externen Bibliothek enthaltenen Funktionen verwenden, die entweder einen Bernoulli-Zahlentyp oder ein Bernoulli-Polynom berechnen.
  • Ihre Antwort muss für alle Eingaben bis einschließlich 60 die richtige Ausgabe ergeben.

Bestenliste

Das Stapel-Snippet am Ende dieses Beitrags generiert die Rangliste aus den Antworten a) als Liste der kürzesten Lösungen pro Sprache und b) als Gesamtrangliste.

Um sicherzustellen, dass Ihre Antwort angezeigt wird, beginnen Sie Ihre Antwort mit einer Überschrift. Verwenden Sie dazu die folgende Markdown-Vorlage:

## Language Name, N bytes

Wo Nist die Größe Ihres Beitrags? Wenn Sie Ihren Score zu verbessern, Sie können alte Rechnungen in der Überschrift halten, indem man sich durch das Anschlagen. Zum Beispiel:

## Ruby, <s>104</s> <s>101</s> 96 bytes

Wenn Sie mehrere Zahlen in Ihre Kopfzeile aufnehmen möchten (z. B. weil Ihre Punktzahl die Summe von zwei Dateien ist oder wenn Sie die Strafen für Interpreter-Flags separat auflisten möchten), stellen Sie sicher, dass die tatsächliche Punktzahl die letzte Zahl in der Kopfzeile ist:

## Perl, 43 + 2 (-p flag) = 45 bytes

Sie können den Namen der Sprache auch als Link festlegen, der dann im Snippet angezeigt wird:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

Code-Snippet anzeigen

code-golf math sequence combinatorics Mego
quelle
@MorganThrapp Die Referenzimplementierung dient nur dazu, die Definition einer Bernoulli-Zahl klarer zu machen und das Problem nicht wirklich zu lösen.
Mego
Ah, gotcha. Ich dachte, es sei eine voll funktionsfähige Implementierung.
Morgan Thrapp
2
@Mego Kein Standard-Float (nicht einmal Quad-Genauigkeit) kann B_60 mit Quad-Genauigkeit speichern. Sollten wir dann ein erweitertes Präzisionsformat verwenden, wenn wir als Dezimalstellen ausgeben?
Lirtosiast
8
Ich mag die Präzisionsanforderung nicht. Einige Sprachen verfügen nicht über die Werkzeuge, um mit Floats mit ausreichender Genauigkeit für B_60 zu arbeiten, und ich würde mich lieber nicht mit solchen Problemen befassen, wenn ich ein mathematisches Problem spiele. Es ist frustrierend, eine Lösung zu schreiben und dann festzustellen, dass sie aus technischen Gründen ungültig ist.
xnor
2
@xnor 6 Stellen Genauigkeit scheint bereits unglaublich lasch.
Primo

Antworten:

8

Julia, 23 20 Bytes

3 Bytes gespart dank Alex A.

Es verwendet dieselbe Formel wie meine Mathematica-Lösung und meine PARI / GP-Lösung .

n->n>0?-zeta(1-n)n:1
Alephalpha
quelle
2
20 Bytes:n->n>0?-zeta(1-n)n:1
Alex A.
@AlexA. Ich weiß nicht warum, aber zeta(n)wirft einen Fehler, wenn neine negative ganze Zahl ist. Ich benutze Julia 0.2.1 unter Linux.
alephalpha
1
Oh mein Gott, deine Version von Julia ist ziemlich veraltet. Es funktioniert gut für mich auf 0.4.1.
Alex A.
25

Mathematica, 40 28 23 22 Bytes

Unter Verwendung der berühmten Formel n * ζ (1 - n ) = - B n , wobei ζ die Riemannsche Zetafunktion ist .

If[#>0,-Zeta[1-#]#,1]&

Die gleiche Länge:

B@0=1;B@n_=-Zeta[1-n]n

Ursprüngliche Lösung, 40 Bytes, unter Verwendung der Erzeugungsfunktion von Bernoulli-Zahlen .

#!SeriesCoefficient[t/(1-E^-t),{t,0,#}]&
Alephalpha
quelle
+2 wenn ich könnte ...
LegionMammal978
9

Julia, 58 Bytes

B(m)=m<1?1:1-sum(k->big(binomial(m,k))*B(k)/(m-k+1),0:m-1)

Dadurch wird eine rekursive Funktion erstellt B, die eine Ganzzahl akzeptiert und einen BigFloat(dh hochgenauen Gleitkommawert) zurückgibt .

Ungolfed:

function B(m::Integer)
    m == 0 && return 1
    return 1 - sum(k -> big(binomial(m, k)) * B(k) / (m-k+1), 0:m-1)
end
Alex A.
quelle
9

Minkolang 0,14 , 97 Bytes

Eigentlich habe ich es zuerst rekursiv versucht, aber mein Dolmetscher, wie er gerade entworfen wurde, kann es tatsächlich nicht. Wenn Sie versuchen, innerhalb einer for-Schleife eine Rekursion durchzuführen, wird eine neue Rekursion gestartet. Also habe ich mich für den tabellarischen Ansatz entschieden ... der Präzisionsprobleme hatte. Also habe ich das Ganze mit Brüchen gemacht. Ohne eingebaute Unterstützung für Brüche. [ seufzt ]

n1+[xxi$z0z2%1+F0c0=$1&$d4Mdm:1R:r$dz1Az0A]$:N.
11z[i0azi6M*i1azi-1+*d0c*1c2c*-1c3c*4$X]f
z1=d1+f

Probieren Sie es hier aus. Bonus: Das Array enthält alle Brüche für jede vorherige Bernoulli-Zahl!

Erklärung (kurz)

n1+                 Take number from input (N) and add 1
   [                Open for loop that runs N+1 times (starts at zero)
    xx              Dump the top two values of the stack
      i$z           Store the loop counter in the register (m)
         0          Push 0
          z2%1+     Push 1 if N is even, 2 if odd
               F    Gosub; pops y,x then goes to codebox(x,y), to be returned to

    0c                                 Copy the first item on the stack
      ,                                1 if equal to 0, 0 otherwise
       $1&                             Jump 11 spaces if top of stack is not 0

                                       (If top of stack is not 0, then...)
          $d                           Duplicate whole stack
            4M                         Pop b,a and push GCD(a,b)
              dm                       Duplicate and merge (a,b,c,c -> a,c,b,c)
                :                      Divide
                 1R                    Rotate 1 item to the right (0G works too)
                   :                   Divide
                    r                  Reverse stack

                                       (In both cases...)
                     $d                Duplicate whole stack
                       z1A             Store denominator of B_m in array
                           z0A         Store numerator of B_m in array
                              ]        Close for loop
                               $:      Divide (float division)
                                 N.    Output as number and stop.

11                                           Push two 1s (a, b)
  z[                                         Open a for loop that repeats m times
    i0a                                      Retrieve numerator of B_k (p)
       zi                                    Push m, k
         6M                                  Pop k,m and push mCk (binomial) (x)
           *                                 p*x (c)
            i1a                              Retrieve denominator of B_k (q)
               zi-1+                         m-k+1 (y)
                    *                        q*y (d)
                     d                       Duplicate top of stack
                      0c*                    a*d
                         1c2c*               b*c
                              -              a*d-b*c
                               1c3c*         b*d
                                    4$X      Dump the bottom four items of stack
                                       ]f    Jump back to F

z          m
 1=        0 (if m is 1) or 1 (otherwise)
   d1+     Duplicate and add 1 (1 or 2)
      f    Jump back to F

Die dritte Zeile ist verantwortlich für 1/2if mist 1 und 0/1if mist eine ungerade Zahl größer als 1. Die zweite Zeile berechnet B_mmit der in der Frage angegebenen Summenformel und zwar vollständig mit Zählern und Nennern. Sonst wäre es viel kürzer. Die erste Hälfte der ersten Zeile führt einige Buchhaltungsaufgaben aus und entscheidet, ob die zweite oder die dritte Zeile ausgeführt werden soll. In der zweiten Hälfte werden Zähler und Nenner durch ihre GCD (falls zutreffend) geteilt und diese Werte gespeichert. Und gibt die Antwort am Ende aus.

El'endia Starman
quelle
8

Python 2, 118 Bytes

6 Bytes aufgrund von xsot gespeichert .
Sparte 6 10 mehr durch Peter Taylor .

n=input()
a=[n%4-1,n<2]*n;exec"a=[(a[j-1]+a[j+1])*j/2for j in range(len(a)-2)];"*~-n
print+(n<1)or-n/(2.**n-4**n)*a[1]

Verwendet die folgende Identität:

wo A n ist die n - te Alternating Anzahl , die formal als die Anzahl der alternierenden Permutationen auf einen Satz von Größe definiert werden kann , n , halbierte (siehe auch: A000111 ).

Der verwendete Algorithmus wurde ursprünglich von Knuth und Buckholtz (1967) angegeben :

Sei T 1, k = 1 für alle k = 1..n

Nachfolgende Werte von T sind durch die Wiederholungsbeziehung gegeben:

T n + 1, k = 1/2 [ (k - 1) T n, k - 1 + (k + 1) T n, k + 1 ]

A n ist dann gegeben durch T n, 1

(siehe auch: A185414 )

Python 2, 152 Bytes

from fractions import*
n=input()
a=[n%4-1,n<2]*n
for k in range(n-1):a=[(a[j-1]+a[j+1])*j/2for j in range(n-k)]
print+(n<1)or Fraction(n*a[1],4**n-2**n)

Gibt die exakte gebrochene Darstellung aus, die für Werte über 200 erforderlich ist.

primo
quelle
1
Wenn Sie ändern range(2,n)zu range(n-2)können verkürzen n-k+1zu n+~k. Gibt es auch einen Grund, den Sie >>1anstelle von verwenden /2? Zuletzt eine triviale Verbesserung, aber Sie können ein paar Bytes durch Aliasing sparen range.
Xsot
Danke für die Vorschläge. Ich hatte ursprünglich zwei Ausdrücke, als ich mich ihnen anschloss, übersah ich das Ändern >>1mit /2.
Primo
1
Es ist eine One-char Einsparung in der Ausgangsleitung: print+(n<1)or-(-1.)**(n+n/2)*n/(4**n-2**n)*a[n%2^1%n]. Und die Berechnung kann für die gleiche Zeichenanzahl erfolgen wiea=[1]*(n+1);exec"a=[(a[j-1]+a[j+1])*j/2for j in range(len(a)-1)];"*(n-1)
Peter Taylor
@PeterTaylor das n+n/2ist schlau; 1 muss nicht herausgegriffen werden, da alle anderen ungeraden Werte ohnehin Null sind. Die alternative Berechnung ist bei Bit-Inversionen tatsächlich 4 Byte kürzer, aber aus irgendeinem Grund auch erheblich langsamer.
Primo
1
Ich habe an der OEIS-Tabelle gearbeitet und dachte, Sie hätten rangeeine Iteration gefunden und ausgelassen, um die Initialisierung zu verkürzen. Die Art und Weise, wie Sie gerade und ungerade Indizes aufteilen, ist sehr schön und ermöglicht ein weiteres Speichern, indem Sie das Vorzeichen in die Definition von a: ziehen a=[(-1)**(n/2),n<2]*n. Dann ist der Rückgabewert +(n<1)or-n/(2.**n-4**n)*a[1]. Sie haben auch ein Streusemikolon am Ende von Zeile 2.
Peter Taylor
6

PARI / GP, 52 23 Bytes

Unter Verwendung der berühmten Formel n * ζ (1 - n ) = - B n , wobei ζ die Riemannsche Zetafunktion ist .

n->if(n,-n*zeta(1-n),1)

Ursprüngliche Lösung, 52 Bytes, unter Verwendung der Erzeugungsfunktion von Bernoulli-Zahlen .

n->n!*polcoeff(-x/sum(i=1,n+1,(-x)^i/i!)+O(x^n*x),n)
Alephalpha
quelle
Kann nur einmal upvoten. Es ist eine Schande, dass es nicht genau ist.
Primo
Laut Dokumentation wird die zetaFunktion tatsächlich mit Bernoulli-Zahlen berechnet.
Primo
@primo, ja, ich betrachte alle Antworten, die das eingebaute Zeta verwenden, als Betrug.
Peter Taylor
Noch einfacher bernfracund bernrealmit jeweils 8 Bytes sind sie bereits funktionsfähig, daher ist das nicht erforderlich n->. Aber +1 für eine gute Lösung.
Charles
6

Python 3, 112 Bytes

Edit: Ich habe diese Antwort aufgeräumt. Wenn Sie alle anderen Möglichkeiten sehen möchten, die ich mir vorgestellt habe, um diese Frage in Python 2 und 3 zu beantworten, lesen Sie die Überarbeitungen.

Wenn ich die Nachschlagetabelle nicht verwende (und stattdessen Memoization verwende), schaffe ich es, die rekursive Definition auf 112 Bytes zu bringen! WOO! Beachten Sie, dass a b(m)zurückgibt Fraction. Wie üblich die Byteanzahl und ein Link zum Testen .

from fractions import*
def b(m):
 s=k=0;p=1
 while k<m:a=m-k;s+=Fraction(p*b(k))/-~a;p=p*a//-~k;k+=1
 return 1-s

Und eine Funktion, die eine Nachschlagetabelle verwendet und die gesamte Bruchtabelle von b(0)bis b(m)einschließlich zurückgibt .

from fractions import*
def b(m,r=[]):
 s=k=0;p=1
 while k<m:
  if k>=len(r):r=b(k,r)
  a=m-k;s+=Fraction(p*r[k])/-~a;p=p*a//-~k;k+=1
 return r+[1-s]
Sherlock9
quelle
1
Ich denke, Sie können die nachgestellte Null bei Float-Literalen weglassen, z . B. 1.anstelle von 1.0.
Alex A.
@AlexA. Getan. Entfernt.0 von sganz, weil es später schnell ein Schwimmer werden wird.
Sherlock9
Können Sie p=v=1;exec('[...];p+=1'*k)anstelle Ihrer innersten Schleife verwenden?
Lirtosiast
5

CJam, 69 49 34 33 Bytes

{_),:):R_:*_@f/@{_(;.-R.*}*0=\d/}

Online-Demo

Vielen Dank an Cabbie407 , dessen Antwort mich auf den Akiyama-Tanigawa-Algorithmus aufmerksam machte.

Präparation

{           e# Function: takes n on the stack
  _),:)     e# Stack: n [1 2 3 ... n+1]
  :R        e# Store that array in R
  _:*       e# Stack: n [1 2 3 ... n+1] (n+1)!
  _@f/      e# Stack: n (n+1)! [(n+1)!/1 (n+1)!/2 (n+1)!/3 ... (n+1)!/(n+1)]
            e#   representing [1/1 1/2 ... 1/(n+1)] but avoiding floating point
  @{        e# Repeat n times:
    _(;.-   e#   Take pairwise differences
    R.*     e#   Pointwise multiply by 1-based indices
  }*        e#   Note that the tail of the array accumulates junk, but we don't care
  0=\d/     e# Take the first element and divide by (n+1)!
}
Peter Taylor
quelle
Mit n multiplizieren ! Präzisionsverlust zu verhindern ist klug, wenn auch nicht leicht lächerlich. Ich frage mich, ob der Algorithmus nicht leicht überarbeitet werden kann, um dies zu vermeiden.
Primo
Ich glaube nicht, dass eine Umgestaltung die Notwendigkeit einer Skalierung aus dem einfachen Grund vermeiden könnte, da wir wissen, dass jede zweite Bernoulli-Zahl 0 ist, werden offensichtlich viele ähnliche Werte subtrahiert kann auftreten.
Peter Taylor
4

PARI / GP, 45 Bytes

n->if(n,2*n/(2^n-4^n)*real(polylog(1-n,I)),1)

Unter Verwendung der gleichen Formel wie meine Python Antwort , mit A n über polylog erzeugt.

Skript testen

Führen Sie gpan der Eingabeaufforderung Folgendes aus:

n->if(n,2*n/(2^n-4^n)*real(polylog(1-n,I)),1)
for(i=0, 60, print(i, ": ", %(i)))
primo
quelle
1
Vielen Dank für die Bereitstellung eines Testskripts - dies hat das Testen erheblich vereinfacht!
Mego
@ Mego für Sie und mich beide;)
Primo
4

Mathematica, 52 48 42 Bytes

1-Sum[#~Binomial~k#0@k/(#-k+1),{k,0,#-1}]&

Unbenannte Funktion, die die Literaldefinition verwendet.

LegionMammal978
quelle
Ist das Sign@#nötig?
alephalpha
Ich habe es auf meinem Computer getestet. Nach dem Entfernen von Sign@#gibt es immer noch die richtige Antwort für 0 zurück.
Alephalpha
3

Python 2, 132 130 Bytes

import math,fractions
f=math.factorial
B=lambda m:~-m*m%2or 1+sum(B(k)*f(m)/f(k)/f(m-k)/fractions.Fraction(k+~m)for k in range(m))

Dies ist nur eine Golfversion der Referenzimplementierung.

Dies ist in der Praxis etwas langsam, kann aber durch Memoization erheblich beschleunigt werden:

import math,fractions
f=math.factorial

def memoize(f):
 memo = {}
 def helper(x):
  if x not in memo:
   memo[x] = f(x)
  return memo[x]
 return helper

@memoize
def B(m):
 return~-m*m%2or 1+sum(B(k)*f(m)/f(k)/f(m-k)/fractions.Fraction(k+~m)for k in range(m))

for m in range(61):
 print(B(m))

Sie können diese Version online auf Ideone testen .

Dennis
quelle
3

gawk4, 79 bytes

77 Byte Code + 2 Byte für -MFlag

PREC^=2{for(n=$0;m++<=n;)for($(j=m)=1/m;j>1;)$j=(-$j+$--j)*j;printf"%.6f",$1}

Es ist eine Implementierung des Akiyama-Tanigawa-Algorithmus von der Wikipedia-Seite.

Hatte einige Probleme mit der "6-Dezimalstellen-Regel", da diese die ganze Zahl und dann 6 Stellen ausgibt, aber es gibt hier keine Liste, um die Ergebnisse zu vergleichen.

Ein Fehler ist, dass dies oftmals ein Minuszeichen vor sich zeigt 0.000000, aber ich denke nicht, dass das falsch ist.

Anwendungsbeispiel

echo 58 | awk -M 'PREC^=2{for(n=$0;m++<=n;)for($(j=m)=1/m;j>1;)$j=(-$j+$--j)*j;printf"%.6f",$1}'

Ausgabe von 0 bis 60

0 -> 1,000000
1 -> 0,500000
2 -> 0,166667
3 -> -0.000000
4 -> -0,033333
5 -> 0,000000
6 -> 0,023810
7 -> 0,000000
8 -> -0,033333
9 -> 0,000000
10 -> 0,075758
11 -> -0.000000
12 -> -0,253114
13 -> -0.000000
14 -> 1,166667
15 -> -0.000000
16 -> -7.092157
17 -> -0.000000
18 -> 54.971178
19 -> -0.000000
20 -> -529.124242
21 -> -0.000000
22 -> 6192.123188
23 -> 0,000000
24 -> -86580.253114
25 -> 0,000000
26 -> 1425517.166667
27 -> 0,000000
28 -> -27298231.067816
29 -> 0,000000
30 -> 601580873.900642
31 -> 0,000000
32 -> -15116315767.092157
33 -> 0,000000
34 -> 429614643061.166667
35 -> 0,000000
36 -> -13711655205088.332772
37 -> 0,000000
38 -> 488332318973593.166667
39 -> -0.000000
40 -> -19296579341940068.148633
41 -> -0.000000
42 -> 841693047573682615.000554
43 -> -0.000000
44 -> -40338071854059455413.076812
45 -> -0.000000
46 -> 2115074863808199160560.145390
47 -> -0.000000
48 -> -120866265222965259346027.311937
49 -> -0.000000
50 -> 7500866746076964366855720.075758
51 -> -0.000000
52 -> -503877810148106891413789303.052201
53 -> -0.000000
54 -> 36528776484818123335110430842.971178
55 -> -0.000000
56 -> -2849876930245088222626914643291.067816
57 -> -0.000000
58 -> 238654274996836276446459819192192.149718
59 -> -0.000000
60 -> -21399949257225333665810744765191097.392674
Cabbie407
quelle
Würde printf"%e"funktionieren
Primo
Nein, würde es nicht, denn die 0.00000s sind nur sehr klein und nicht wirklich Null.
Cabbie407
2

GolfScript, 63 Bytes

~:i.!+.[3i&(2i>]*i(,{i\-,{1$1$(=2$2$)=+*2/}%\;}/~\2i?.(*\--1?**

Online Demo .

Verwenden Sie die gleiche Formel wie meine Python-Antwort .

Skript testen

61,{[.`
  ~:i.!+.[3i&(2i>]*i(,{i\-,{1$1$(=2$2$)=+*2/}%\;}/~\2i?.(*\--1?**
]p}/

Der AppHB-Link wird diesbezüglich eine Zeitüberschreitung aufweisen. Wenn Sie GolfScript nicht lokal installiert haben, empfehle ich die Verwendung des Anarchy Golf Interpreters (Formular verwenden, GolfScript auswählen, einfügen, senden).

primo
quelle
2

Perl, 101 Bytes

#!perl -p
@a=($_%4-1,$_<2)x$_;
@a=map$_*($a[$_-1]+$a[$_+1])/2,0..@a-3for 2..$_;
$_=!$_||$_/(4**$_-2**$_)*$a[1]

Zählt man den Shebang als drei, wird die Eingabe von stdin übernommen.

Verwenden Sie die gleiche Formel wie meine Python-Antwort .

Beispielnutzung

$ echo 60 | perl bernoulli.pl
-2.13999492572253e+034

Online Demo .

primo
quelle
2

R 93 Bytes

function(m){if(m==0){1}else{v=c();for(k in 0:(m-1))v=c(v,choose(m,k)*f(k)/(m-k+1));1-sum(v)}}

Nicht wirklich originell als Lösung. Wenn Sie einen Kommentar haben, zögern Sie nicht!

Ungolfed:

function(m)
    if(m==0){1}
    else
         v=c()
         for(k in 0:(m-1))
            v=c(v,choose(m,k)*f(k)/(m-k+1))

1-sum(v)
Frédéric
quelle
Ich weiß, dass dies jetzt etwas spät ist, aber Sie können 3 Bytes sparen, indem Sie die if/ elsestatement-Reihenfolge ändern und verwenden m>0sowie 1:m-1stattdessen eine Schleife durchführen .
Billywob
2

Eigentlich , 46 45 Bytes (nicht konkurrierende)

Ich wollte schon seit Monaten eine ernsthafte / tatsächliche Antwort geben und jetzt kann ich. Da dies Befehle verwendet, die Seriously im November 2015 nicht hatte, ist es nicht konkurrierend. Golfvorschläge sind willkommen. Probieren Sie es online!

Bearbeiten: Im Februar 2017 gab es ein Update auf Actually, das änderte, welche Funktionsliterale welche sind. Normalerweise würde dies für jede Herausforderung, die vor Februar geschrieben wurde, einfach nicht konkurrieren, aber da diese Antwort bereits nicht konkurriert, habe ich diese Antwort trotzdem bearbeitet. Genießen.

Hierfür wird die explizite Definition der Bernoulli-Zahlen in Wikipedia verwendet.

;╖ur⌠;╝ur⌠;;0~ⁿ(╛█*╜(uⁿ*⌡MΣ╛uk⌡M┬i@;π;)♀\*@k▼

Ungolfing

;╖     Duplicate and save m in register 0.
ur     Range [0..m]
  ⌠      Start first for loop
  ;╝     Duplicate and save k in register 1.
  ur     Range [0..k]
    ⌠      Start second for loop (as string).
    ;;     Duplicate v twice.
    0~ⁿ    Push -1, and pow() to get (-1)**v.
    (╛█    Rotate a duplicate v to TOS, push k, and binom(k, v).
    *      Multiply (-1)**v by binom(k, v).
    ╜(uⁿ   Push m, rotate last duplicate v to TOS, increment, and pow() to get (v+1)**m.
    *      (-1)**v * binom(k, v) * (v+1)**m
    ⌡      End second for loop (string turned to function).
  MΣ     Map over range [0..v] and sum
  ╛u     Push k and increment (the denominator)
           (Note: second for loop does numerators only as denominator only depends on k)
  k      Push fraction in list form [numerator, denominator]
  ⌡      End first for loop
M      Map over range [0..k]
┬i@    Transpose all of the fractions, flatten and swap.
         Stack: [denominators] [numerators]
;π     Duplicate and take product of denominators.
;)     Duplicate product and move to bottom of stack.
         Stack: product [denominators] [numerators] product
♀\     For all items in denominators, integer divide product by item.
         Return a list of these scaled-up denominators.
*      Dot product of numerators and the scaled-up denominators as new numerator.
         (In effect, getting the fractions to the same denominator and summing them)
@k     Swap new numerator and product (new denominator) and turn into a list (fraction).
▼      Divide fraction by gcd(numerator, denominator) (Simplify fraction).
Sherlock9
quelle
2
Benutzt Befehle, die es im November 2015 nicht gegeben hat? Mann, das ist eine völlig neue Sprache , die es im November 2015 noch nicht gab! Ich bin so stolz ...
Mego
1

Rubin, 66 61 Bytes

Dies ist eine Ruby-Version meiner Python-Antwort.

b=->m{s,p=0r,1;m.times{|k|a=m-k;s+=p*b[k]/-~a;p=p*a/-~k};1-s}

Da dies Rationalin seinen Antworten verwendet wird, bin ich mir ziemlich sicher, dass dies bis zu 60 funktioniert, aber ich hatte sogar Probleme beim Ausführen b[24], so dass ich die Nachschlagetabelle erneut für 86 81 80 Bytes implementiert habe .

t=->m{s,p,r=0r,1,m>0?t[m-1]:[];m.times{|k|a=m-k;s+=p*r[k]/-~a;p=p*a/-~k};r<<1-s}
Sherlock9
quelle
1

J 10 Bytes

(%1-^@-)t:

Berechnet die n- te Bernoulli-Zahl, indem der n- te Koeffizient der exponentiellen Erzeugungsfunktion von x ermittelt wird / (1 - e -x ).

Verwendung

Wenn der Eingabe eine Ganzzahl oder ein Gleitkomma als Argument übergeben wird, wird ein Gleitkomma ausgegeben. Wenn eine erweiterte Ganzzahl angegeben wird, wird diese mit einem Suffix markiertx , wird entweder eine erweiterte Ganzzahl oder eine rationale, zwei durch getrennte erweiterte Ganzzahlen ausgegeben r.

   f =: (%1-^@-)t:
   f 1
0.5
   f 1x
1r2
   (,.f"0) i. 10x
0     1
1   1r2
2   1r6
3     0
4 _1r30
5     0
6  1r42
7     0
8 _1r30
9     0

Erläuterung

(%1-^@-)t: Input: n
(      )t: Takes a monad and creates a new monad that
           computes the coefficients of its egf
(      )   A monad that operates on x
      -      Negate x
    ^@       Computes its exponential, e^-x
  1-         Subtract it from 1
 %           Divide x by it, x/(1 - e^-x)
Meilen
quelle
1

Axiom, 134 147 Bytes

b(n:NNI):FRAC INT==(v:=[1/1];k:=1;repeat(k>n=>break;r:=1-reduce(+,[binomial(k,j)*v.(j+1)/(k-j+1)for j in 0..k-1]);v:=append(v,[r]);k:=k+1);v.(n+1))

ungolf und test

(23) -> b
   (23)
   b n ==
           1
     v := [-]
           1
     k := 1
     repeat
       if n < k
         then break
         else
                               binomial(k,j)v(j + 1)
           r := 1 - reduce(+,[[--------------------- for j in 0..(k - 1)]])
                                     k - j + 1
           v := append(v,[r])
           k := k + 1
     v(n + 1)
                                                   Type: FunctionCalled b
(50) -> [[i,b(i)]  for i in [0,1,2,3,4,5,6,7,8,9,10]]
   (50)
             1     1              1            1              1             5
   [[0,1],[1,-],[2,-],[3,0],[4,- --],[5,0],[6,--],[7,0],[8,- --],[9,0],[10,--]]
             2     6             30           42             30            66
                                         Type: List List Fraction Integer

(51) -> b 1000
   (51)
   -
   18243104738661887254572640256857788879338336867042906052197158157641126_
    2572624911158657472577321069709615489924627495522908087488299539455188_
    7918567582241551668492697244184914012242579830955617098629924652251740_
    9791915637226361428342780548971002281045465308441161372350696920220116_
    2441791760680262602019620260255790058416539271332852806000966628467639_
    0683434226380702951226108116666172815817157023611889303668166839919156_
    3797683877845690114843122753427426880591799883780255338278664578660218_
    5045895962670442011443630321460259486764674312436994856054301765557425_
    1371150213401051058408679874766352952749178734973676859834707623881634_
    6251471489942512878190574323531299070406930309477389251738705417680653_
    1183648189451892725726445949589759600705334767585389769924857630972963_
    9976364832442643512622073858780110731539833099817555775136008111170797_
    6250597322951308884900670113339167641953793994512377610306198429310933_
    1214632141683542607746641232089854815064629129596536997380608256428801_
    9784909897301658268809203555030692846151917069465607257641149187197651_
    0905515966840312411845543650593021402849221691341852819791233589301994_
    1012291773441794027493574651881059432274494354092231954894280742068472_
    7146192942133436054611475404867886313250114399681532753236429290625909_
    3411000391368336312138915621701535954814084208794241665492294270773347_
    6055878415765927582014214726584822236443691314366097570085473354584000_
    9985915190584047337934331297339403392719579093995842312746836871169674_
    9786460913411872527166990047126222109345933847358924230951718379883743_
    2563465487604170316077418754242710065269818190591271690695446633836120_
    3745255515267088218383996330164203403732365333352120338272021319718003_
    5994220458994876460018350270385634117807768745161622933834063145505621_
    9106004731529642292049578901
     /
    342999030
                                                   Type: Fraction Integer

(52) -> b 60
           1215233140483755572040304994079820246041491
   (52)  - -------------------------------------------
                             56786730
                                                   Type: Fraction Integer
RosLuP
quelle
1

APL (NARS), 83 Zeichen, 166 Byte

r←B w;i
r←,1⋄i←0x⋄w+←1
→3×⍳w≤i+←1⋄r←r,1-+/{(1+i-⍵)÷⍨(⍵!i)×r[⍵+1]}¨0..i-1⋄→2
r←r[i]

Eingabe als Integerausgabe als Big Rational

  B 0
1
  B 1
1r2 
  B 2
1r6 
  B 3
0 
  B 4
¯1r30 
  B 10
5r66 
  B 100
¯94598037819122125295227433069493721872702841533066936133385696204311395415197247711r33330 
  B 1000
¯1824310473866188725457264025685778887933833686704290605219715815764112625726249111586574725773210697096154899246
  27495522908087488299539455188791856758224155166849269724418491401224257983095561709862992465225174097919156
  37226361428342780548971002281045465308441161372350696920220116244179176068026260201962026025579005841653927
  13328528060009666284676390683434226380702951226108116666172815817157023611889303668166839919156379768387784
  56901148431227534274268805917998837802553382786645786602185045895962670442011443630321460259486764674312436
  99485605430176555742513711502134010510584086798747663529527491787349736768598347076238816346251471489942512
  87819057432353129907040693030947738925173870541768065311836481894518927257264459495897596007053347675853897
  69924857630972963997636483244264351262207385878011073153983309981755577513600811117079762505973229513088849
  00670113339167641953793994512377610306198429310933121463214168354260774664123208985481506462912959653699738
  06082564288019784909897301658268809203555030692846151917069465607257641149187197651090551596684031241184554
  36505930214028492216913418528197912335893019941012291773441794027493574651881059432274494354092231954894280
  74206847271461929421334360546114754048678863132501143996815327532364292906259093411000391368336312138915621
  70153595481408420879424166549229427077334760558784157659275820142147265848222364436913143660975700854733545
  84000998591519058404733793433129733940339271957909399584231274683687116967497864609134118725271669900471262
  22109345933847358924230951718379883743256346548760417031607741875424271006526981819059127169069544663383612
  03745255515267088218383996330164203403732365333352120338272021319718003599422045899487646001835027038563411
  78077687451616229338340631455056219106004731529642292049578901r342999030
RosLuP
quelle
0

Haskell, 95 Bytes

import Data.Ratio
p=product
b m=sum[p[k-v+1..k]*(v+1)^m%(p[-v..0-1]*(k+1))|k<-[0..m],v<-[0..k]]

Dies implementiert die explizite Definition von Bernoulli-Zahlen auf der Wikipedia-Seite .

Sherlock9
quelle
0

Perl 6, 83 Bytes

my &B={$^m??1-[+] (^$m).map: {combinations($m,$_)*B($_)/($m+1-$_)}!!1};say B slurp;

Eine schnellere 114-Byte-Lösung:

my @b=1;for 1..+slurp() {@b.push: 1-[+] (^$^m).map: {([*] $m+1-$_..$m)*@b[$_]/($m+1-$_)/([*] 1..$_)}};say @b[*-1];
bb94
quelle
Ihr Code für eine Code-Golf-Herausforderung muss so kurz wie möglich sein, auch wenn es einige Lebensdauern des Universums dauert, bis er für bestimmte Eingaben beendet ist.
Mego
0

Javascript, 168 Bytes

function h(b,a){return a?h(a,b%a):b}for(var c=[],a=[],e=0,b,d,f,g;e<=k;)for(c[b=d=e]=1,a[e]=++e;d;)f=c[--d]*a[b]-(c[b]*=g=a[d]),r=h(f*=b,g=a[b]*=g),c[d]=f/r,a[--b]=g/r;

Setzen Sie die Variable 'k' auf die gewünschte Bernoulli-Zahl und das Ergebnis ist c [0] über a [0]. (Zähler Nenner)

Beispielnutzung

k = 2;
console.log(c[0] + "/" + a[0]);

Nicht so klein wie die anderen, aber der einzige, den ich geschrieben habe, der nahe kommt. Unter https://marquisdegeek.com/code_ada99 finden Sie Informationen zu meinen anderen (nicht Golf-) Versuchen.

Marquis de Geek
quelle
0

Axiom, 57 Bytes

g(n)==factorial(n)*coefficient(taylor(t*%e^t/(%e^t-1)),n)

Code für Test und Ergebnisse

(18) -> [[i, g(i)]  for i in 0..29]
   (18)
              1      1                1              1                1
   [[0,1], [1,-], [2,-], [3,0], [4,- --], [5,0], [6,--], [7,0], [8,- --],
              2      6               30             42               30
                5                  691               7                 3617
    [9,0], [10,--], [11,0], [12,- ----], [13,0], [14,-], [15,0], [16,- ----],
               66                 2730               6                  510
                43867                 174611               854513
    [17,0], [18,-----], [19,0], [20,- ------], [21,0], [22,------], [23,0],
                 798                    330                  138
          236364091               8553103                 23749461029
    [24,- ---------], [25,0], [26,-------], [27,0], [28,- -----------], [29,0]]
             2730                    6                        870
                                       Type: List List Expression Integer

(19) -> g 60
           1215233140483755572040304994079820246041491
   (19)  - -------------------------------------------
                             56786730
                                                 Type: Expression Integer

man muss beachten, dass die Funktion nicht diejenige ist, die oben geschrieben wurde, sondern t*%e^t/(%e^t-1))mit% e Euler costant

RosLuP
quelle
0

Pyth , 22 Bytes

L?b-1sm*.cbdcyd-btdUb1

Probieren Sie es online!

Definiert eine Funktion, die aufgerufen wird als y<number>z yQ.

L                      # y=lambda b:
 ?b                  1 # ... if b else 1
   -1                  # 1 -
     s                 #     sum(
      m            Ub  #         map(lambda d: ... , range(b)) 
       *.cbd           #           combinations(b, d) *
            cyd        #             y(d) /      (float division)
               -btd    #                    b - (d - 1)
ar4093
quelle