베르누이 수 (즉, 제 베르누이 번호)은 다음 순환 정의에 의해 정의된다 :

여기서 조합을 나타냅니다 .

음수가 아닌 정수 m를 입력 으로 받으면 십진수 표현 또는 m두 번째 베르누이 수에 대해 감소 된 분수를 출력합니다 . 소수점 표현을 출력하는 경우 최소 6 자리 소수점 이하 자릿수 (소수점 뒤의 숫자)가 있어야하며 소수점 이하 6 자리로 올림 할 때 정확해야합니다. 예를 들어,에 대한 m = 2, 0.166666523허용는 반올림 때문에 0.166667. 0.166666389로 반올림되므로 허용되지 않습니다 0.166666. 후행 0은 생략 될 수 있습니다. 과학적 표기법은 10 진수 표현에 사용될 수 있습니다.

다음은 m소수점 이하 6 자리로 반올림 한 과학적 표기법으로, 최대 60을 포함한 최대 60까지 의 입력 및 예상 출력입니다 .

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) 전체 리더 보드로 답변에서 리더 보드를 생성합니다.

답변이 표시되도록하려면 다음 마크 다운 템플릿을 사용하여 헤드 라인으로 답변을 시작하십시오.

## 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 20 바이트

Alex A 덕분에 3 바이트 절약

내 Mathematica 솔루션 및 PARI / GP 솔루션 과 동일한 공식을 사용합니다 .

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

매스 매 티카, 40 28 23 22 바이트

유명한 공식 인 n * ζ (1- n ) = -B _{n을 사용합니다} . 여기서 ζ 는 Riemann Zeta 함수 입니다.

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

같은 길이 :

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

Bernoulli 수의 생성 기능을 사용 하는 원래 솔루션, 40 바이트 .

#!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정수를 받아들이고 a를 반환하는 재귀 함수 를 만듭니다 .BigFloat (즉, 고정밀 부동 소수점)을 .

언 골프 드 :

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

미 콜랑 0.14 , 97 바이트

실제로 재귀 적으로 먼저 시도했지만 현재 설계된 통역사가 실제로 할 수 없습니다. for 루프 내에서 재귀를 시도하면 새로운 재귀가 시작됩니다. 그래서 나는 정밀한 문제가있는 테이블 방식으로 갔다. 그래서 나는 분수로 모든 일을했습니다. 분수를 기본적으로 지원하지 않습니다. [ 한숨 ]

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

여기에서 시도하십시오.보너스 :이 배열에는 이전의 모든 Bernoulli 수에 대한 모든 분수가 있습니다!

설명 (약간)

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/2if m가 1이고 0/1if m가 홀수보다 큰 1을 담당합니다. 두 번째 줄 B_m은 질문에 주어진 합산 공식으로 계산 되며 분자와 분모를 사용하여 계산 됩니다. 그렇지 않으면 훨씬 짧을 것입니다. 첫 번째 줄의 첫 번째 절반은 일부 부기를 수행하고 두 번째 또는 세 번째 줄을 실행할지 여부를 선택하고 두 번째 절반은 분자와 분모를 GCD (해당되는 경우)로 나누고 해당 값을 저장합니다. 그리고 마지막에 답을 출력합니다.

파이썬 2, 118 바이트

xsot 로 인해 6 바이트를 절약했습니다 . Peter Taylor 덕분에 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]

다음 ID를 사용합니다.

여기서 A _n 은 n ^번째 대체 수 이며, 크기 n 의 집합에 대한 교호 순열의 수를 반으로 정의 할 수 있습니다 (또한 A000111 참조 ).

사용 된 알고리즘은 원래 Knuth and Buckholtz (1967)가 제공했습니다 .

모든 k = 1..n에 대해 T _{1, k} = 1 이라고합시다.

T의 후속 값은 반복 관계에 의해 제공됩니다.

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

_N은 다음 T 주어진다 _{n, 1에}

(또한 참조 : A185414 )

파이썬 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 이상의 값에 필요한 정확한 분수 표현을 인쇄합니다.

파리 / GP, 52 23 바이트

유명한 공식 인 n * ζ (1- n ) = -B _{n을 사용합니다} . 여기서 ζ 는 Riemann Zeta 함수 입니다.

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

Bernoulli 수의 생성 기능을 사용 하는 원래 솔루션, 52 바이트 .

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

파이썬 3, 112 바이트

편집 : 이 답변을 정리했습니다. 파이썬 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)

A _n 과 함께 Python 답변 과 동일한 수식을 사용합니다. polylog 통해 생성.

테스트 스크립트

실행 gp프롬프트에 다음을 붙여 넣습니다 :

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

매스 매 티카, 52 48 42 바이트

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

리터럴 정의를 사용하는 이름이없는 함수입니다.

파이썬 2, 132130 바이트

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 바이트

-M플래그의 경우 77 바이트 코드 + 2 바이트

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

Wikipedia 페이지의 Akiyama–Tanigawa 알고리즘을 구현 한 것입니다.

정수와 6 자리를 인쇄하지만 결과를 비교할 목록이 없기 때문에 "6 자리 10 진수 규칙"에 문제가있었습니다.

결함은 이것 앞에 마이너스 부호를 인쇄한다는 것입니다. 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 선택, 붙여 넣기, 제출)를 사용하는 것이 좋습니다 .

펄, 101 바이트

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

shebang을 3으로 계산하여 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)}}

해결책으로 독창적이지는 않습니다. 의견이 있으시면 언제든지 문의하십시오!

언 골프 :

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 년 11 월에 없었던 명령을 사용하기 때문에 경쟁이 아닙니다. 골프 제안을 환영합니다. 온라인으로 사용해보십시오!

편집하다: 2017 년 2 월 실제로 실제로 어떤 함수 리터럴이 변경되었는지에 대한 업데이트가있었습니다. 일반적으로 이것은 2 월 이전에 작성된 문제에 대해 경쟁이되지 않을 것입니다. 그러나이 답변은 이미 경쟁이 아니기 때문에 어쨌든이 답변을 편집했습니다. 즐겨.

Wikipedia에서 Bernoulli 수의 명시 적 정의를 사용합니다.

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

언 골핑

;╖     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 바이트

이것은 내 파이썬 답변의 루비 버전입니다.

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:

x / (1- e ^-x ) 의 지수 생성 함수의 n ^번째 계수를 찾아 n ^번째 Bernoulli 수를 계산합니다 .

용법

입력에 정수가 주어 지거나 인수로 float 인 경우 float가 출력됩니다. 접미사로 표시된 확장 정수가 제공되면 x확장 정수 또는로 분리 된 합리적인 두 확장 정수를 출력합니다 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

설명

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

풀고 테스트

(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 

하스켈, 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]]

이것은 Wikipedia 페이지 에 요약 된 Bernoulli 숫자의 명시 적 정의를 구현합니다 .

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

자바 스크립트, 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 수로 설정하면 결과는 a [0]에 대해 c [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 Euler costant라는 점에 유의해야합니다.

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)