Nomor Bernoulli

23

Angka Bernoulli (khususnya, angka Bernoulli kedua) didefinisikan oleh definisi rekursif berikut:

nomor Bernoulli kedua

Di mana mCkmenunjukkan kombinasi .

Diberikan integer nonnegatif msebagai input, menampilkan representasi desimal ATAU fraksi tereduksi untuk mbilangan Bernoulli kedua. Jika Anda menghasilkan representasi desimal, Anda harus memiliki setidaknya 6 tempat desimal (digit setelah titik desimal), dan itu harus akurat ketika dibulatkan ke 6 tempat desimal. Misalnya, untuk m = 2, 0.166666523dapat diterima karena membulatkan ke 0.166667. 0.166666389tidak dapat diterima, karena membulatkan ke 0.166666. Angka nol yang tertinggal dapat dihilangkan. Notasi ilmiah dapat digunakan untuk representasi desimal.

Berikut adalah input dan output yang diharapkan mhingga dan termasuk 60, dalam notasi ilmiah dibulatkan ke 6 tempat desimal, dan sebagai pecahan tereduksi:

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)

Implementasi referensi (dalam 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

Aturan

  • Ini adalah kode-golf , jadi kode terpendek dalam byte menang
  • Anda tidak boleh menggunakan fungsi apa pun, baik bawaan atau yang disertakan dalam perpustakaan eksternal, yang menghitung jenis nomor Bernoulli atau polinomial Bernoulli.
  • Jawaban Anda harus memberikan output yang benar untuk semua input hingga dan termasuk 60.

Papan peringkat

Cuplikan Stack di bagian bawah posting ini menghasilkan leaderboard dari jawaban a) sebagai daftar solusi terpendek per bahasa dan b) sebagai leaderboard keseluruhan.

Untuk memastikan bahwa jawaban Anda muncul, silakan mulai jawaban Anda dengan tajuk utama, menggunakan templat Penurunan harga berikut:

## Language Name, N bytes

di mana Nukuran kiriman Anda. Jika Anda meningkatkan skor Anda, Anda bisa menyimpan skor lama di headline, dengan mencoretnya. Contohnya:

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

Jika Anda ingin memasukkan beberapa angka dalam tajuk Anda (mis. Karena skor Anda adalah jumlah dari dua file atau Anda ingin membuat daftar hukuman penterjemah secara terpisah), pastikan bahwa skor sebenarnya adalah angka terakhir di tajuk:

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

Anda juga dapat membuat nama bahasa menjadi tautan yang kemudian akan muncul di cuplikan:

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

Tampilkan cuplikan kode

code-golf math sequence combinatorics Mego
sumber
@MorganThrapp Implementasi referensi hanya untuk memperjelas definisi nomor Bernoulli, bukan untuk benar-benar menyelesaikan masalah.
Mego
Ah, mengerti. Saya pikir itu adalah implementasi yang berfungsi penuh.
Morgan Thrapp
2
@Mego Tidak ada standar float (bahkan presisi quad) dapat menyimpan B_60 ke presisi quad. Haruskah kita menggunakan format presisi yang diperluas jika kita mengeluarkan sebagai desimal?
lirtosiast
8
Saya tidak suka persyaratan presisi. Beberapa bahasa tidak memiliki alat untuk bekerja dengan float dengan akurasi yang cukup untuk B_60, dan saya lebih suka tidak berurusan dengan masalah seperti itu ketika bermain golf masalah matematika. Sangat frustasi untuk menulis solusi dan kemudian menemukan bahwa itu tidak valid karena apa yang tampak seperti teknis.
xnor
2
@xnor 6 digit akurasi tampaknya sudah sangat longgar.
primo

Jawaban:

8

Julia, 23 20 byte

Disimpan 3 byte berkat Alex A.

Ini menggunakan rumus yang sama dengan solusi Mathematica saya dan solusi PARI / GP .

n->n>0?-zeta(1-n)n:1
alephalpha
sumber
2
20 byte:n->n>0?-zeta(1-n)n:1
Alex A.
@AlexA. Saya tidak tahu mengapa, tetapi zeta(n)melempar kesalahan ketika nbilangan bulat negatif. Saya menggunakan Julia 0.2.1 di linux.
alephalpha
1
Ya ampun, versi Julia Anda sudah cukup usang. Ini berfungsi dengan baik untuk saya di 0.4.1.
Alex A.
25

Mathematica, 40 28 23 22 byte

Menggunakan rumus terkenal n * ζ (1− n ) = - B n , di mana ζ adalah fungsi Riemann Zeta .

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

Panjang yang sama:

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

Solusi asli, 40 byte, menggunakan fungsi pembangkit nomor Bernoulli .

#!SeriesCoefficient[t/(1-E^-t),{t,0,#}]&
alephalpha
sumber
+2 jika aku bisa ...
LegionMammal978
9

Julia, 58 byte

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

Ini menciptakan fungsi rekursif Byang menerima bilangan bulat dan mengembalikan BigFloat(yaitu titik mengambang presisi tinggi).

Tidak Disatukan:

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.
sumber
9

Minkolang 0,14 , 97 byte

Saya sebenarnya mencoba melakukannya secara rekursif dulu, tetapi penerjemah saya, seperti yang saat ini dirancang, sebenarnya tidak bisa melakukannya. Jika Anda mencoba untuk mengulang dari dalam untuk loop, itu memulai rekursi baru. Jadi saya pergi untuk pendekatan tabulasi ... yang memiliki masalah presisi. Jadi saya melakukan semuanya dengan fraksi. Tanpa dukungan bawaan untuk pecahan. [ menghela nafas ]

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

Coba di sini.Bonus: array memiliki semua fraksi untuk setiap nomor Bernoulli sebelumnya!

Penjelasan (sedikit)

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

Baris ketiga bertanggung jawab untuk 1/2jika madalah 1 dan 0/1jika mangka ganjil lebih besar dari 1. Baris kedua menghitung B_mdengan rumus penjumlahan yang diberikan dalam pertanyaan, dan melakukannya sepenuhnya dengan pembilang dan penyebut. Kalau tidak, akan jauh lebih pendek. Paruh pertama dari baris pertama melakukan pembukuan dan memilih apakah akan mengeksekusi baris kedua atau ketiga, dan separuh kedua membagi pembilang dan penyebut dengan GCD mereka (jika ada) dan menyimpan nilai-nilai tersebut. Dan mengeluarkan jawaban di akhir.

El'endia Starman
sumber
8

Python 2, 118 byte

Disimpan 6 byte karena xsot .
Disimpan 6 10 lebih karena 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]

Gunakan identitas berikut:

di mana A n adalah n th Alternating Nomor , yang dapat secara formal didefinisikan sebagai jumlah permutasi bolak pada satu set ukuran n , dibelah dua (lihat juga: A000111 ).

Algoritma yang digunakan pada awalnya diberikan oleh Knuth dan Buckholtz (1967) :

Misalkan T 1, k = 1 untuk semua k = 1..n

Nilai T selanjutnya diberikan oleh relasi rekurensi:

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

A n kemudian diberikan oleh T n, 1

(lihat juga: A185414 )

Python 2, 152 byte

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)

Mencetak representasi pecahan yang tepat, yang diperlukan untuk nilai yang lebih besar dari 200 atau lebih.

primo
sumber
1
Jika Anda mengubah range(2,n)ke range(n-2)Anda dapat mempersingkat n-k+1untuk n+~k. Juga, apakah ada alasan Anda menggunakan >>1bukan /2? Terakhir, peningkatan sepele, tetapi Anda dapat menyimpan beberapa byte dengan aliasing range.
xsot
Terima kasih atas sarannya. Aku awalnya memiliki dua ekspresi, ketika saya bergabung dengan mereka saya diabaikan berubah >>1dengan /2.
primo
1
Ada penghematan satu-char di jalur output: print+(n<1)or-(-1.)**(n+n/2)*n/(4**n-2**n)*a[n%2^1%n]. Dan perhitungan dapat dilakukan untuk jumlah char yang sama sepertia=[1]*(n+1);exec"a=[(a[j-1]+a[j+1])*j/2for j in range(len(a)-1)];"*(n-1)
Peter Taylor
@PeterTaylor si n+n/2pintar; Saya tidak perlu dipilih, karena semua nilai ganjil lainnya adalah nol. Perhitungan alternatif sebenarnya 4 byte lebih pendek dengan bit inversi, tetapi juga jauh lebih lambat, karena beberapa alasan.
primo
1
Saya sedang bekerja dari tabel OEIS, dan berpikir bahwa Anda telah menemukan rangedan melewatkan satu iterasi menjadi cara yang cerdas untuk mempersingkat inisialisasi. Cara Anda sekarang membagi indeks genap dan ganjil sangat bagus, dan memungkinkan penghematan lebih lanjut dengan menarik tanda ke dalam definisi a:a=[(-1)**(n/2),n<2]*n . Maka nilai baliknya adalah +(n<1)or-n/(2.**n-4**n)*a[1]. Anda juga mendapat tanda titik koma di akhir baris 2.
Peter Taylor
6

PARI / GP, 52 23 byte

Menggunakan rumus terkenal n * ζ (1− n ) = - B n , di mana ζ adalah fungsi Riemann Zeta .

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

Solusi asli, 52 byte, menggunakan fungsi pembangkit nomor Bernoulli .

n->n!*polcoeff(-x/sum(i=1,n+1,(-x)^i/i!)+O(x^n*x),n)
alephalpha
sumber
Hanya dapat memilih satu kali. Sayang sekali itu tidak tepat.
primo
Menurut dokumentasi , zetafungsi dihitung menggunakan angka Bernoulli.
primo
@ primo, ya, saya menganggap semua jawaban yang menggunakan zeta bawaan sebagai curang.
Peter Taylor
Lebih mudah, bernfracdan bernrealmasing-masing 8 byte dan mereka sudah berfungsi, jadi tidak perlu n->. Tapi +1 untuk solusi yang bagus.
Charles
6

Python 3, 112 byte

Edit: Saya membersihkan jawaban ini. Jika Anda ingin melihat semua cara lain yang saya pikirkan untuk menjawab pertanyaan ini dengan Python 2 dan 3, lihat revisi.

Jika saya tidak menggunakan tabel pencarian (dan saya menggunakan memoisasi), saya berhasil mendapatkan definisi rekursif hingga 112 byte! MERAYU! Perhatikan bahwa b(m)mengembalikan a Fraction. Seperti biasa, jumlah byte dan tautan untuk pengujian .

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

Dan fungsi yang menggunakan tabel pencarian, dan mengembalikan seluruh tabel fraksi dari b(0)hingga b(m), inklusif.

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
sumber
1
Saya pikir Anda dapat menghilangkan trailing zero pada liter mengapung, misalnya 1.bukan 1.0.
Alex A.
@AlexA. Selesai Dihapus .0dari sseluruhnya, karena akan cepat menjadi pelampung nantinya.
Sherlock9
Bisakah Anda menggunakan p=v=1;exec('[...];p+=1'*k)sebagai ganti loop terdalam Anda?
lirtosiast
5

CJam, 69 49 34 33 byte

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

Demo online

Terima kasih kepada Cabbie407 , yang jawabannya membuat saya sadar akan algoritma Akiyama-Tanigawa.

Pembedahan

{           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
sumber
Mengalikan melalui n! untuk mencegah kehilangan presisi adalah pintar, jika tidak sedikit konyol. Saya ingin tahu apakah algoritme tidak dapat direactored sedikit untuk menghindari ini.
primo
Saya tidak berpikir refactoring dapat menghindari kebutuhan untuk skala karena alasan sederhana bahwa karena kita tahu bahwa setiap angka Bernoulli lainnya adalah 0 jelas ada banyak pengurangan nilai yang sama terjadi, jadi ada banyak tempat di mana kehilangan signifikansi bencana dapat terjadi.
Peter Taylor
4

PARI / GP, 45 byte

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

Menggunakan rumus yang sama dengan jawaban Python saya , dengan A n dihasilkan melalui polylog.

Skrip Tes

Jalankan gp, pada prompt tempelkan yang berikut:

n->if(n,2*n/(2^n-4^n)*real(polylog(1-n,I)),1)
for(i=0, 60, print(i, ": ", %(i)))
primo
sumber
1
Terima kasih telah menyediakan skrip pengujian - ini membuat pengujian ini jauh lebih mudah!
Mego
@Mego untuk Anda dan saya berdua;)
primo
4

Mathematica, 52 48 42 byte

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

Fungsi tanpa nama yang menggunakan definisi literal.

LegionMammal978
sumber
Apakah itu Sign@#perlu?
alephalpha
Saya mengujinya di komputer saya. Setelah menghapus Sign@#, masih mengembalikan jawaban yang benar untuk 0.
alephalpha
3

Python 2, 132 130 byte

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

Ini hanya versi golf dari implementasi referensi.

Ini agak lambat dalam praktiknya, tetapi dapat dipercepat secara signifikan dengan memoisasi:

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

Anda dapat mencoba versi ini secara online di Ideone .

Dennis
sumber
3

gawk4, 79 byte

77 byte kode + 2 byte untuk -Mflag

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

Ini merupakan implementasi dari algoritma Akiyama-Tanigawa dari halaman Wikipedia.

Mengalami masalah dengan "6-desimal-digit-rule", karena ini mencetak seluruh angka dan kemudian 6 digit, tetapi tidak ada daftar di sini untuk membandingkan hasilnya.

Kelemahannya adalah ini mencetak tanda minus di depan 0.000000banyak kali, tapi saya tidak berpikir itu salah.

Contoh penggunaan

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

Output dari 0 hingga 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
sumber
Akan printf"%e"bekerja
primo
Tidak, tidak akan, karena 0.00000s hanya sangat kecil dan tidak benar-benar nol.
Cabbie407
2

GolfScript, 63 byte

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

Demo online .

Menggunakan rumus yang sama dengan jawaban Python saya .

Skrip Tes

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

Tautan apphb akan kehabisan waktu untuk hal ini. Jika Anda belum menginstal GolfScript secara lokal, saya sarankan menggunakan juru bahasa anarki golf (gunakan formulir, pilih GolfScript, tempel, kirim).

primo
sumber
2

Perl, 101 byte

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

Menghitung shebang sebagai tiga, input diambil dari stdin.

Menggunakan rumus yang sama dengan jawaban Python saya .

Contoh Penggunaan

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

Demo online .

primo
sumber
2

R, 93 byte

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

Tidak terlalu orisinal sebagai solusi. Jika ada komentar, silakan saja!

Tidak Terkumpul:

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
sumber
Saya tahu ini agak terlambat sekarang tetapi Anda dapat menyimpan 3 byte dengan mengubah urutan if/ elsepernyataan dan menggunakan m>0serta mengulangi sebagai 1:m-1gantinya.
Billywob
2

Sebenarnya , 46 45 byte (tidak bersaing)

Saya sudah bermaksud melakukan jawaban Serius / Sebenarnya selama berbulan-bulan dan sekarang saya bisa. Karena ini menggunakan perintah yang tidak dimiliki oleh Serius pada bulan November 2015, itu tidak bersaing. Saran bermain golf diterima.Cobalah online!

Edit: Pada bulan Februari 2017, ada pembaruan untuk Actually yang mengubah fungsi literal mana. Biasanya, ini tidak akan bersaing untuk tantangan yang ditulis sebelum Februari, tetapi karena jawaban ini sudah tidak bersaing, saya tetap mengedit jawaban ini. Nikmati.

Ini menggunakan definisi eksplisit nomor Bernoulli di Wikipedia.

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

Tidak melakukanolf

;╖     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
sumber
2
Menggunakan perintah. Serius tidak memilikinya pada November 2015? Sobat, ini menggunakan bahasa yang sama sekali baru yang tidak ada pada bulan November 2015! Saya sangat bangga ...
Mego
1

Ruby, 66 61 byte

Ini adalah versi Ruby dari jawaban Python saya.

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

Karena ini menggunakan Rationaldalam jawabannya, saya cukup yakin ini berfungsi hingga 60, tapi saya mengalami kesulitan menjalankan bahkan b[24], jadi saya menerapkan tabel pencarian lagi untuk 86 81 80 byte.

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
sumber
1

J, 10 byte

(%1-^@-)t:

Menghitung angka Bernoulli ke- n dengan menemukan koefisien ke- n dari fungsi pembangkit eksponensial x / (1 - e -x ).

Pemakaian

Jika input diberikan integer atau float sebagai argumen, itu akan menampilkan float. Jika diberi bilangan bulat yang diperluas, ditandai dengan akhiran x, itu akan menghasilkan bilangan bulat yang diperluas atau yang rasional, dua bilangan bulat yang diperpanjang dipisahkan oleh 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

Penjelasan

(%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)
mil
sumber
1

Aksioma, 134 147 byte

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 dan tes

(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
sumber
1

APL (NARS), 83 karakter, 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]

Input sebagai output integer sebagai rasional besar

  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
sumber
0

Haskell, 95 byte

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

Ini mengimplementasikan definisi eksplisit nomor Bernoulli yang diuraikan di halaman Wikipedia .

Sherlock9
sumber
0

Perl 6, 83 byte

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

Solusi 114 byte yang lebih cepat:

my @b=1;for 1..+slurp() {@b.push: 1-[+] (^$^m).map: {([*] $m+1-$_..$m)*@b[$_]/($m+1-$_)/([*] 1..$_)}};say @b[*-1];
bb94
sumber
Kode Anda untuk tantangan kode golf harus sesingkat mungkin, bahkan jika diperlukan beberapa masa kehidupan semesta untuk mengakhiri input tertentu.
Mego
0

Javascript, 168 byte

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;

Setel variabel 'k' ke nomor Bernoulli yang Anda inginkan, dan hasilnya adalah c [0] di atas [0]. (pembilang & penyebut)

Contoh Penggunaan

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

Tidak sekecil yang lain, tetapi satu-satunya yang saya tulis yang mendekati. Lihat https://marquisdegeek.com/code_ada99 untuk upaya (non-golf) saya yang lain.

Marquis de Geek
sumber
0

Aksioma, 57 byte

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

kode untuk pengujian dan hasil

(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

kita harus perhatikan bahwa fungsinya bukan yang seseorang tulis di atas tetapi t*%e^t/(%e^t-1))dengan% e Euler costant

RosLuP
sumber
0

Pyth , 22 byte

L?b-1sm*.cbdcyd-btdUb1

Cobalah online!

Menentukan fungsi yang disebut sebagai y<number>, mis 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
sumber