Các số Bernoulli (cụ thể là các số Bernoulli thứ hai) được xác định theo định nghĩa đệ quy sau:

Trường hợp biểu thị một sự kết hợp .

Cho một số nguyên không âm mlàm đầu vào, xuất đại diện thập phân HOẶC một phần giảm cho msố Bernoulli thứ hai. Nếu bạn xuất một biểu diễn thập phân, bạn phải có ít nhất 6 chữ số thập phân (chữ số sau dấu thập phân) của độ chính xác và nó phải chính xác khi được làm tròn đến 6 chữ số thập phân. Ví dụ, cho m = 2, 0.166666523được chấp nhận bởi vì nó làm tròn đến 0.166667. 0.166666389không được chấp nhận, bởi vì nó làm tròn đến 0.166666. Số 0 Trailing có thể được bỏ qua. Ký hiệu khoa học có thể được sử dụng cho các biểu diễn thập phân.

Dưới đây là đầu vào và đầu ra dự kiến ​​cho mtối đa và bao gồm 60, theo ký hiệu khoa học được làm tròn đến 6 chữ số thập phân và dưới dạng phân số giảm:

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)

Tham chiếu thực hiện (trong 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

Quy tắc

• Đây là mã golf , vì vậy mã ngắn nhất tính bằng byte thắng
• Bạn không được sử dụng bất kỳ hàm nào, có sẵn hoặc được bao gồm trong một thư viện bên ngoài, tính toán loại số Bernoulli hoặc đa thức Bernoulli.
• Câu trả lời của bạn phải đưa ra đầu ra chính xác cho tất cả các đầu vào lên đến và bao gồm 60.

Bảng xếp hạng

Đoạn trích ở cuối bài này tạo ra bảng xếp hạng từ các câu trả lời a) dưới dạng danh sách các giải pháp ngắn nhất cho mỗi ngôn ngữ và b) dưới dạng bảng xếp hạng tổng thể.

Để đảm bảo rằng câu trả lời của bạn hiển thị, vui lòng bắt đầu câu trả lời của bạn bằng một tiêu đề, sử dụng mẫu Markdown sau:

## Language Name, N bytes

nơi Nlà kích thước của trình của bạn. Nếu bạn cải thiện điểm số của mình, bạn có thể giữ điểm số cũ trong tiêu đề, bằng cách đánh bại chúng thông qua. Ví dụ:

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

Nếu bạn muốn bao gồm nhiều số trong tiêu đề của mình (ví dụ: vì điểm của bạn là tổng của hai tệp hoặc bạn muốn liệt kê riêng các hình phạt cờ của thông dịch viên), hãy đảm bảo rằng điểm thực tế là số cuối cùng trong tiêu đề:

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

Bạn cũng có thể đặt tên ngôn ngữ thành liên kết sau đó sẽ hiển thị trong đoạn trích:

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

<style>body { text-align: left !important} #answer-list { padding: 10px; width: 290px; float: left; } #language-list { padding: 10px; width: 290px; float: left; } table thead { font-weight: bold; } table td { padding: 5px; }</style><script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="language-list"> <h2>Shortest Solution by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr> </thead> <tbody id="languages"> </tbody> </table> </div> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr> </thead> <tbody id="answers"> </tbody> </table> </div> <table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table><script>var QUESTION_ID = 65382; var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe"; var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk"; var OVERRIDE_USER = 45941; var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page; function answersUrl(index) { return "https://api.stackexchange.com/2.2/questions/" + QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER; } function commentUrl(index, answers) { return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER; } function getAnswers() { jQuery.ajax({ url: answersUrl(answer_page++), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { answers.push.apply(answers, data.items); answers_hash = []; answer_ids = []; data.items.forEach(function(a) { a.comments = []; var id = +a.share_link.match(/\d+/); answer_ids.push(id); answers_hash[id] = a; }); if (!data.has_more) more_answers = false; comment_page = 1; getComments(); } }); } function getComments() { jQuery.ajax({ url: commentUrl(comment_page++, answer_ids), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { data.items.forEach(function(c) { if (c.owner.user_id === OVERRIDE_USER) answers_hash[c.post_id].comments.push(c); }); if (data.has_more) getComments(); else if (more_answers) getAnswers(); else process(); } }); } getAnswers(); var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/; var OVERRIDE_REG = /^Override\s*header:\s*/i; function getAuthorName(a) { return a.owner.display_name; } function process() { var valid = []; answers.forEach(function(a) { var body = a.body; a.comments.forEach(function(c) { if(OVERRIDE_REG.test(c.body)) body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>'; }); var match = body.match(SCORE_REG); if (match) valid.push({ user: getAuthorName(a), size: +match[2], language: match[1], link: a.share_link, }); else console.log(body); }); valid.sort(function (a, b) { var aB = a.size, bB = b.size; return aB - bB }); var languages = {}; var place = 1; var lastSize = null; var lastPlace = 1; valid.forEach(function (a) { if (a.size != lastSize) lastPlace = place; lastSize = a.size; ++place; var answer = jQuery("#answer-template").html(); answer = answer.replace("{{PLACE}}", lastPlace + ".") .replace("{{NAME}}", a.user) .replace("{{LANGUAGE}}", a.language) .replace("{{SIZE}}", a.size) .replace("{{LINK}}", a.link); answer = jQuery(answer); jQuery("#answers").append(answer); var lang = a.language; lang = jQuery('<a>'+lang+'</a>').text(); languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang.toLowerCase(), user: a.user, size: a.size, link: a.link}; }); var langs = []; for (var lang in languages) if (languages.hasOwnProperty(lang)) langs.push(languages[lang]); langs.sort(function (a, b) { if (a.lang_raw > b.lang_raw) return 1; if (a.lang_raw < b.lang_raw) return -1; return 0; }); for (var i = 0; i < langs.length; ++i) { var language = jQuery("#language-template").html(); var lang = langs[i]; language = language.replace("{{LANGUAGE}}", lang.lang) .replace("{{NAME}}", lang.user) .replace("{{SIZE}}", lang.size) .replace("{{LINK}}", lang.link); language = jQuery(language); jQuery("#languages").append(language); } }</script>

Julia, 23 20 byte

Đã lưu 3 byte nhờ Alex A.

Nó sử dụng cùng một công thức như giải pháp Mathicala và giải pháp PARI / GP của tôi .

n->n>0?-zeta(1-n)n:1

Toán học, 40 28 23 22 byte

Sử dụng công thức nổi tiếng n * ζ (1− n ) = - B _n , trong đó ζ là hàm Riemann Zeta .

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

Độ dài tương tự:

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

Giải pháp gốc, 40 byte, sử dụng hàm tạo số Bernoulli .

#!SeriesCoefficient[t/(1-E^-t),{t,0,#}]&

Julia, 58 byte

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

Điều này tạo ra một hàm đệ quy Bchấp nhận một số nguyên và trả về một BigFloat(tức là điểm nổi có độ chính xác cao).

Ung dung:

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

Chồn 0,14 , 97 byte

Tôi thực sự đã thử làm nó một cách đệ quy trước tiên, nhưng thông dịch viên của tôi, như được thiết kế hiện tại, thực sự không thể làm được. Nếu bạn cố gắng lặp lại từ trong vòng lặp for, nó sẽ bắt đầu một đệ quy mới. Vì vậy, tôi đã đi theo cách tiếp cận theo bảng ... có vấn đề chính xác. Vì vậy, tôi đã làm toàn bộ với phân số. Không có hỗ trợ tích hợp cho phân số. [ thở dài ]

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

Hãy thử nó ở đây. Phần thưởng: mảng có tất cả các phân số cho mỗi số Bernoulli trước đó!

Giải thích (một chút)

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

Dòng thứ ba chịu trách nhiệm 1/2nếu mlà 1 và 0/1nếu mlà số lẻ lớn hơn 1. Dòng thứ hai tính toán B_mvới công thức tính tổng được đưa ra trong câu hỏi và hoàn toàn làm như vậy với tử số và mẫu số. Nếu không thì nó sẽ ngắn hơn rất nhiều. Nửa đầu của dòng đầu tiên thực hiện một số sổ sách kế toán và chọn thực hiện dòng thứ hai hoặc thứ ba, và nửa thứ hai chia tử số và mẫu số cho GCD của chúng (nếu có) và lưu các giá trị đó. Và đưa ra câu trả lời ở cuối.

Python 2, 118 byte

Đã lưu 6 byte do xsot .
Cứu được 6 10 người nữa nhờ 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]

Sử dụng danh tính sau:

Trong đó A _n là Số luân phiên ^thứ n , có thể được định nghĩa chính thức là số lượng hoán vị xen kẽ trên một tập hợp kích thước n , giảm một nửa (xem thêm: A000111 ).

Thuật toán được sử dụng ban đầu được đưa ra bởi Knuth và Buckholtz (1967) :

Cho T _{1, k} = 1 với mọi k = 1..n

Các giá trị tiếp theo của T được đưa ra bởi mối quan hệ lặp lại:

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

A _n sau đó được cho bởi T _{n, 1}

(xem thêm: 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)

In biểu diễn phân số chính xác, cần thiết cho các giá trị lớn hơn 200 hoặc hơn.

PARI / GP, 52 23 byte

Sử dụng công thức nổi tiếng n * ζ (1− n ) = - B _n , trong đó ζ là hàm Riemann Zeta .

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

Giải pháp gốc, 52 byte, sử dụng hàm tạo số Bernoulli .

n->n!*polcoeff(-x/sum(i=1,n+1,(-x)^i/i!)+O(x^n*x),n)

Python 3, 112 byte

Chỉnh sửa: Tôi đã làm sạch câu trả lời này. Nếu bạn muốn xem tất cả các cách khác mà tôi nghĩ để trả lời câu hỏi này trong Python 2 và 3, hãy xem các bản sửa đổi.

Nếu tôi không sử dụng bảng tra cứu (và thay vào đó tôi sử dụng ghi nhớ), tôi quản lý để có được định nghĩa đệ quy đến 112 byte! Ôi! Lưu ý rằng b(m)trả về a Fraction. Như thường lệ, số byte và một liên kết để kiểm tra .

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

Và một hàm sử dụng bảng tra cứu và trả về toàn bộ bảng phân số từ b(0)đến b(m), bao gồm.

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]

CJam, 69 49 34 33 byte

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

Bản demo trực tuyến

Nhờ Cabbie407 , người có câu trả lời khiến tôi biết về thuật toán Akiyama từ Tanigawa.

Mổ xẻ

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

PARI / GP, 45 byte

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

Sử dụng cùng một công thức như câu trả lời Python của tôi , với A _n được tạo thông qua polylog.

Kiểm tra tập lệnh

Chạy gp, tại dấu nhắc dán như sau:

n->if(n,2*n/(2^n-4^n)*real(polylog(1-n,I)),1)
for(i=0, 60, print(i, ": ", %(i)))

Toán học, 52 48 42 byte

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

Hàm không tên sử dụng định nghĩa theo nghĩa đen.

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

Đây chỉ là một phiên bản golf của việc thực hiện tham chiếu.

Đây là một chút chậm trong thực tế, nhưng có thể được tăng tốc đáng kể với ghi nhớ:

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

Bạn có thể thử phiên bản trực tuyến này trên Ideone .

gawk4, 79 byte

77 byte mã + 2 byte cho -Mcờ

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

Đây là một triển khai của thuật toán Akiyama từ Tanigawa từ trang Wikipedia.

Có một số rắc rối với "quy tắc 6 chữ số thập phân", bởi vì điều này in toàn bộ số và sau đó là 6 chữ số, nhưng không có danh sách nào ở đây để so sánh kết quả.

Một lỗ hổng là điều này in một dấu trừ ở phía trước 0.000000 rất nhiều lần, nhưng tôi không nghĩ đó là sai.

Ví dụ sử dụng

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

Đầu ra từ 0 đến 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

GolfScript, 63 byte

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

Demo trực tuyến .

Sử dụng cùng một công thức như câu trả lời Python của tôi .

Kiểm tra tập lệnh

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

Liên kết apphb sẽ hết thời gian này. Nếu bạn không cài đặt GolfScript cục bộ, tôi khuyên bạn nên sử dụng trình thông dịch golf vô chính phủ (sử dụng mẫu, chọn GolfScript, dán, gửi).

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]

Đếm shebang là ba, đầu vào được lấy từ stdin.

Sử dụng cùng một công thức như câu trả lời Python của tôi .

Sử dụng mẫu

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

Demo trực tuyến .

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

Không thực sự ban đầu là một giải pháp. Nếu có bất kỳ bình luận, xin vui lòng!

Ung dung:

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)

Trên thực tế , 46 45 byte (không cạnh tranh)

Tôi đã có ý định thực hiện một câu trả lời Nghiêm túc / Thực tế trong nhiều tháng và bây giờ tôi có thể. Vì điều này sử dụng các lệnh mà Nghiêm túc không có vào tháng 11 năm 2015, nên nó không cạnh tranh. Gợi ý chơi golf chào mừng. Hãy thử trực tuyến!

Chỉnh sửa: Vào tháng 2 năm 2017, đã có một bản cập nhật cho Trên thực tế đã thay đổi chức năng nghĩa đen là gì. Thông thường, điều này chỉ đơn giản là không cạnh tranh cho bất kỳ thử thách nào được viết trước tháng 2, nhưng vì câu trả lời này đã không cạnh tranh, nên tôi đã chỉnh sửa câu trả lời này. Thưởng thức.

Điều này sử dụng định nghĩa rõ ràng về các số Bernoulli trên Wikipedia.

;╖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).

Ruby, 66 61 byte

Đây là phiên bản Ruby của câu trả lời Python của tôi.

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

Vì điều này sử dụng Rationaltrong các câu trả lời của nó, tôi khá chắc chắn rằng nó hoạt động tới 60, nhưng tôi gặp khó khăn khi chạy b[24], vì vậy tôi đã thực hiện lại bảng tra cứu cho 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}

J, 10 byte

(%1-^@-)t:

Tính số Bernoulli ^thứ n bằng cách tìm hệ số ^thứ n của hàm tạo hàm mũ của x / (1 - e ^-x ).

Sử dụng

Nếu đầu vào được đưa ra số nguyên hoặc thả nổi làm đối số, nó sẽ xuất ra một số float. Nếu được cung cấp một số nguyên mở rộng, được đánh dấu bằng hậu tốx , nó sẽ xuất ra một số nguyên mở rộng hoặc một số nguyên mở rộng, hai số nguyên mở rộng cách nhau bởi 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

Giải trình

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

Tiên đề, 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 và kiểm tra

(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

APL (NARS), 83 ký tự, 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]

Đầu vào là đầu ra số nguyên như hợp lý lớn

  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 

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

Điều này thực hiện định nghĩa rõ ràng về các số Bernoulli được nêu trên trang Wikipedia .

Perl 6, 83 byte

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

Một giải pháp 114 byte nhanh hơn:

my @b=1;for 1..+slurp() {@b.push: 1-[+] (^$^m).map: {([*] $m+1-$_..$m)*@b[$_]/($m+1-$_)/([*] 1..$_)}};say @b[*-1];

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;

Đặt biến 'k' thành số Bernoulli bạn muốn và kết quả là c [0] trên [0]. (tử số & mẫu số)

Sử dụng mẫu

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

Không nhỏ như những người khác, nhưng là người duy nhất tôi đã viết đến gần. Xem https://marquisdegeek.com/code_ada99 để biết các nỗ lực khác (không phải chơi gôn) của tôi.

Tiên đề, 57 byte

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

mã kiểm tra và kết quả

(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

người ta phải lưu ý rằng hàm không phải là cái mà ai đó đã viết ở trên mà t*%e^t/(%e^t-1))với% e Euler costant

Bình thường , 22 byte

L?b-1sm*.cbdcyd-btdUb1

Hãy thử trực tuyến!

Xác định một hàm được gọi là y<number>, ví dụ 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)