หมายเลข Bernoulli (เฉพาะที่สองหมายเลข Bernoulli) จะถูกกำหนดโดยคำนิยาม recursive ต่อไปนี้:

ในกรณีที่หมายถึงการรวมกัน

รับจำนวนเต็มไม่ใช่ค่าลบmเป็นอินพุตเอาต์พุตเอาต์พุตการแทนทศนิยมหรือเศษส่วนที่ลดลงสำหรับmหมายเลข Bernoulli ที่สอง หากคุณแสดงการแทนทศนิยมคุณต้องมีตำแหน่งทศนิยมอย่างน้อย 6 ตำแหน่ง (ตัวเลขหลังจุดทศนิยม) และจะต้องแม่นยำเมื่อปัดเศษเป็นทศนิยม 6 ตำแหน่ง ตัวอย่างเช่นสำหรับm = 2, เป็นที่ยอมรับเพราะมันรอบ0.166666523 เป็นที่ยอมรับไม่ได้เพราะมันรอบ ศูนย์ต่อท้ายอาจถูกละเว้น สัญลักษณ์ทางวิทยาศาสตร์อาจใช้สำหรับการแทนทศนิยม0.1666670.1666663890.166666

นี่คืออินพุตและเอาต์พุตที่คาดว่าmจะถึงและรวมถึง 60 ในเครื่องหมายทางวิทยาศาสตร์ปัดเศษเป็นทศนิยม 6 ตำแหน่งและเป็นเศษส่วนที่ลดลง:

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)

การใช้งานอ้างอิง (ใน 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

กฎระเบียบ

• นี่คือcode-golfดังนั้นรหัสที่สั้นที่สุดในหน่วยไบต์ชนะ
• คุณไม่สามารถใช้ฟังก์ชั่นใด ๆ ไม่ว่าจะเป็นในตัวหรือรวมอยู่ในห้องสมุดภายนอกที่คำนวณหมายเลข Bernoulli หรือชื่อพหุนาม Bernoulli ประเภทใดประเภทหนึ่ง
• คำตอบของคุณจะต้องให้ผลลัพธ์ที่ถูกต้องสำหรับอินพุตทั้งหมดจนถึงและรวมถึง 60

ลีดเดอร์บอร์ด

สแต็คส่วนย่อยที่ด้านล่างของโพสต์นี้สร้างกระดานแต้มนำจากคำตอบ a) เป็นรายการคำตอบสั้นที่สุดต่อภาษาและ b) เป็นกระดานแต้มนำโดยรวม

เพื่อให้แน่ใจว่าคำตอบของคุณปรากฏขึ้นโปรดเริ่มคำตอบด้วยหัวข้อโดยใช้เทมเพลต Markdown ต่อไปนี้:

## Language Name, N bytes

ที่Nมีขนาดของส่งของคุณ หากคุณปรับปรุงคะแนนของคุณคุณสามารถเก็บคะแนนเก่าไว้ในพาดหัวโดยการตีพวกเขาผ่าน ตัวอย่างเช่น

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

หากคุณต้องการรวมหลายตัวเลขไว้ในส่วนหัวของคุณ (เช่นเนื่องจากคะแนนของคุณคือผลรวมของไฟล์สองไฟล์หรือคุณต้องการแสดงรายการบทลงโทษการตั้งค่าสถานะของล่ามแยกต่างหาก) ตรวจสอบให้แน่ใจว่าคะแนนจริงเป็นตัวเลขสุดท้ายในส่วนหัว:

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

คุณสามารถทำให้ชื่อภาษาเป็นลิงค์ซึ่งจะปรากฏในตัวอย่างข้อมูล:

## [><>](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>

จูเลีย23 23ไบต์

บันทึกแล้ว 3 ไบต์ขอบคุณ Alex A.

ใช้สูตรเดียวกับโซลูชัน MathematicaและโซลูชันPARI / GP ของฉัน

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

Mathematica, 40 28 23 22 ไบต์

โดยใช้สูตรที่มีชื่อเสียงn * ζ (1- n ) = - B _nที่ζเป็นฟังก์ชั่นซีตา Riemann

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

ความยาวเท่ากัน:

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

วิธีการแก้ปัญหาเดิม 40 ไบต์โดยใช้ฟังก์ชั่นการสร้างของหมายเลข Bernoulli

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

จูเลีย 58 ไบต์

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

สิ่งนี้จะสร้างฟังก์ชั่นวนซ้ำBซึ่งยอมรับจำนวนเต็มและส่งกลับจุดBigFloat(เช่นจุดลอยตัวที่มีความแม่นยำสูง)

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

Minkolang 0.14 , 97 ไบต์

ที่จริงฉันพยายามทำมันซ้ำก่อน แต่ล่ามของฉันตามที่ได้รับการออกแบบในปัจจุบันไม่สามารถทำได้ หากคุณพยายามที่จะเรียกคืนจากภายในวงสำหรับมันจะเริ่มการสอบถามซ้ำใหม่ ดังนั้นฉันจึงไปที่ตารางวิธี ... ซึ่งมีปัญหาความแม่นยำ ดังนั้นฉันจึงทำทั้งหมดด้วยเศษส่วน ไม่มีการสนับสนุนเศษส่วนในตัว [ ถอนหายใจ ]

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

ลองที่นี่ โบนัส: อาเรย์มีเศษส่วนสำหรับทุกเบอร์เบอร์นูลี่ก่อนหน้า!

คำอธิบาย (เล็กน้อย)

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

บรรทัดที่สามรับผิดชอบ1/2หากmเป็น 1 และ0/1หากmเป็นเลขคี่ที่มากกว่า 1 บรรทัดที่สองคำนวณB_mด้วยสูตรการรวมที่กำหนดในคำถามและดำเนินการทั้งหมดด้วยตัวเศษและส่วน มิฉะนั้นจะสั้นกว่ามาก ครึ่งแรกของบรรทัดแรกทำบัญชีบางอย่างและเลือกว่าจะดำเนินการบรรทัดที่สองหรือสามและครึ่งหลังจะแบ่งตัวเศษและส่วนด้วย GCD ของพวกเขา (ถ้ามี) และเก็บค่าเหล่านั้น และออกคำตอบในตอนท้าย

Python 2, 118 ไบต์

ที่บันทึกไว้ 6 ไบต์เนื่องจากxsot
ที่บันทึกไว้6 10 มากขึ้นเนื่องจากปีเตอร์เทย์เลอร์

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]

ใช้ข้อมูลเฉพาะตัวต่อไปนี้:

โดยที่A _nคือn ^th จำนวนสลับซึ่งสามารถกำหนดอย่างเป็นทางการเป็นจำนวนพีชคณิตสลับกับชุดของขนาดที่nลดลงครึ่งหนึ่ง (ดูเพิ่มเติมที่: A000111 )

อัลกอริทึมที่ใช้ได้รับมาโดยKnuth และ Buckholtz (1967) :

ให้ T _{1, k} = 1 สำหรับทุก k = 1..n

ค่าที่ตามมาของ T ถูกกำหนดโดยความสัมพันธ์ที่เกิดซ้ำ:

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

_nจะได้รับแล้วโดย T _{n 1}

(ดูเพิ่มเติมที่: A185414 )

Python 2, 152 ไบต์

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)

พิมพ์การแทนค่าเศษส่วนที่แน่นอนซึ่งจำเป็นสำหรับค่าที่มากกว่า 200 หรือมากกว่านั้น

PARI / GP, 52 23 ไบต์

โดยใช้สูตรที่มีชื่อเสียงn * ζ (1- n ) = - B _nที่ζเป็นฟังก์ชั่นซีตา Riemann

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

วิธีการแก้ปัญหาเดิม 52 ไบต์โดยใช้ฟังก์ชั่นการสร้างของหมายเลข Bernoulli

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

Python 3, 112 ไบต์

แก้ไข:ฉันล้างคำตอบนี้ หากคุณต้องการดูวิธีอื่น ๆ ทั้งหมดที่ฉันคิดว่าจะตอบคำถามนี้ใน Python 2 และ 3 ให้ดูในการแก้ไข

หากฉันไม่ใช้ตารางการค้นหา (และฉันใช้การบันทึกความจำแทน) ฉันจะจัดการเพื่อให้คำจำกัดความซ้ำถึง 112 ไบต์! แอ่ว! โปรดทราบว่าผลตอบแทนb(m) Fractionตามปกตินับไบต์และการเชื่อมโยงสำหรับการทดสอบ

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

และฟังก์ชั่นที่ใช้ตารางการค้นหาและส่งกลับตารางเศษส่วนทั้งหมดจากb(0)ถึงb(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 ไบต์

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

การสาธิตออนไลน์

ขอบคุณที่ Cabbie407ซึ่งคำตอบทำให้ฉันตระหนักถึงอัลกอริทึม Akiyama – Tanigawa

การผ่า

{           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 ไบต์

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

ใช้สูตรเดียวกันกับคำตอบของPythonกับA _nสร้างผ่าน polylog

สคริปต์ทดสอบ

เรียกใช้gpที่พร้อมท์ให้วางต่อไปนี้:

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

Mathematica, 52 48 42 ไบต์

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

ฟังก์ชันที่ไม่มีชื่อที่ใช้นิยามตามตัวอักษร

Python 2, 132 130 ไบต์

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

นี่เป็นเพียงการนำเวอร์ชันอ้างอิงมาใช้

นี่เป็นเพียงเล็กน้อยในทางปฏิบัติช้า แต่สามารถเร่งความเร็วอย่างมีนัยสำคัญด้วยการบันทึก:

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

คุณสามารถลองรุ่นนี้ออนไลน์บนIdeone

gawk4, 79 ไบต์

77 รหัสไบต์ + 2 ไบต์สำหรับ -Mตั้งค่าสถานะ

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

มันเป็นการใช้งานอัลกอริทึมของ Akiyama – Tanigawa จากหน้า Wikipedia

มีปัญหากับ "กฎทศนิยม 6 หลัก" เพราะจะพิมพ์ตัวเลขทั้งหมดแล้วตามด้วยตัวเลข 6 หลัก แต่ไม่มีรายการใดที่นี่เพื่อเปรียบเทียบผลลัพธ์

ข้อบกพร่องคือสิ่งนี้พิมพ์เครื่องหมายลบที่ด้านหน้า 0.000000หลายครั้ง แต่ฉันไม่คิดว่ามันผิด

ตัวอย่างการใช้งาน

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

เอาต์พุตจาก 0 ถึง 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 ไบต์

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

สาธิตออนไลน์

โดยใช้สูตรเดียวกับฉันคำตอบหลาม

สคริปต์ทดสอบ

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

ลิงก์ apphb จะหมดเวลาในการนี้ หากคุณไม่มี GolfScript ติดตั้งไว้ภายในเครื่องฉันขอแนะนำให้ใช้ล่ามอนาธิปไตยกอล์ฟ (ใช้แบบฟอร์มเลือก GolfScript วางส่ง)

Perl, 101 ไบต์

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

นับ Shebang เป็นสามเข้าถูกนำมาจาก stdin

โดยใช้สูตรเดียวกับฉันคำตอบหลาม

ตัวอย่างการใช้งาน

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

สาธิตออนไลน์

R, 93 ไบต์

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

ไม่ได้เป็นแบบดั้งเดิมจริงๆเป็นวิธีแก้ปัญหา หากความคิดเห็นใด ๆ โปรดอย่าลังเล!

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)

อันที่จริง , 46 45 ไบต์ (ที่ไม่ใช่การแข่งขัน)

ฉันตั้งใจจะตอบอย่างจริงจัง / จริง ๆ เป็นเวลาหลายเดือนและตอนนี้ฉันสามารถทำได้ เนื่องจากสิ่งนี้ใช้คำสั่งที่ไม่มีในเดือนพฤศจิกายนปี 2015 อย่างจริงจังจึงไม่ใช่การแข่งขัน ยินดีต้อนรับคำแนะนำการเล่นกอล์ฟ ลองออนไลน์!

แก้ไข:ในเดือนกุมภาพันธ์ 2017 มีการอัปเดตเป็นจริงซึ่งเปลี่ยนแปลงตัวอักษรฟังก์ชันใด โดยปกติสิ่งนี้จะไม่แข่งขันสำหรับความท้าทายใด ๆ ที่เขียนก่อนเดือนกุมภาพันธ์ แต่เนื่องจากคำตอบนี้ไม่ได้แข่งขันกันเลยฉันจึงแก้ไขคำตอบนี้ต่อไป สนุก.

สิ่งนี้ใช้คำจำกัดความที่ชัดเจนของตัวเลขเบอร์นูลีบนวิกิพีเดีย

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

ทับทิม, 66 61 ไบต์

นี่เป็นคำตอบ Python ของฉันในเวอร์ชัน Ruby

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

เนื่องจากสิ่งนี้ใช้Rationalในคำตอบของฉันฉันค่อนข้างแน่ใจว่านี้ทำงานได้ถึง 60 แต่ฉันมีปัญหาในการทำงานแม้b[24]ดังนั้นฉันจึงใช้ตารางการค้นหาอีกครั้งสำหรับ86 81 80 ไบต์

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 ไบต์

(%1-^@-)t:

คำนวณn ^THจำนวน Bernoulli โดยการหาn ^THค่าสัมประสิทธิ์ของฟังก์ชั่นการสร้างชี้แจงของx / (1 - E ^-x )

การใช้

หากอินพุตได้รับจำนวนเต็มหรือลอยเป็นอาร์กิวเมนต์ก็จะส่งออกลอย หากได้รับจำนวนเต็มขยายที่มีเครื่องหมายคำต่อท้ายก็จะส่งออกทั้งจำนวนเต็มขยายหรือเหตุผลสองจำนวนเต็มขยายคั่นด้วยxr

   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

คำอธิบาย

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

ความจริง134 147 ไบต์

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 และทดสอบ

(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 ตัวอักษร, 166 ไบต์

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]

อินพุตเป็นเอาต์พุตจำนวนเต็มเป็นเหตุผลใหญ่

  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 ไบต์

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

การดำเนินการนี้คำนิยามที่ชัดเจนของหมายเลข Bernoulli ที่ระบุไว้บนหน้าวิกิพีเดีย

Perl 6, 83 ไบต์

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

โซลูชันที่เร็วกว่า 114 ไบต์:

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

Javascript, 168 ไบต์

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;

ตั้งค่าตัวแปร 'k' เป็นหมายเลข Bernoulli ที่คุณต้องการและผลลัพธ์คือ c [0] บน [0] (ตัวเศษและส่วน)

ตัวอย่างการใช้งาน

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

ไม่เล็กเหมือนคนอื่น ๆ แต่มีเพียงคนเดียวที่ฉันเขียนที่เข้ามาใกล้ ดูhttps://marquisdegeek.com/code_ada99สำหรับความพยายามอื่น ๆ ของฉัน (ไม่ใช่กอล์ฟ)

ความจริง 57 ไบต์

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

รหัสสำหรับการทดสอบและผลลัพธ์

(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

เราต้องทราบว่าฟังก์ชั่นไม่ใช่คนที่เขียนไว้ข้างต้น แต่t*%e^t/(%e^t-1))ด้วย% e ออยเลอร์

Pyth , 22 ไบต์

L?b-1sm*.cbdcyd-btdUb1

ลองออนไลน์!

กำหนดฟังก์ชั่นที่เรียกว่าเป็นเช่นy<number>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)