Números de Bernoulli

23

Los números de Bernoulli (específicamente, los segundos números de Bernoulli) se definen mediante la siguiente definición recursiva:

segundos números de Bernoulli

Donde mCkdenota una combinación .

Dado un entero no negativo mcomo entrada, genera la representación decimal O una fracción reducida para el msegundo número de Bernoulli. Si genera una representación decimal, debe tener al menos 6 decimales (dígitos después del punto decimal) de precisión, y debe ser precisa cuando se redondea a 6 decimales. Por ejemplo, para m = 2, 0.166666523es aceptable porque se redondea a 0.166667. 0.166666389no es aceptable, ya que se redondea a 0.166666. Los ceros finales pueden omitirse. La notación científica puede usarse para representaciones decimales.

Aquí está la entrada y la salida esperada mhasta 60 inclusive, en notación científica redondeada a 6 decimales, y como fracciones reducidas:

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)

Implementación de referencia (en 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

Reglas

  • Este es el código de golf , por lo que gana el código más corto en bytes
  • No puede usar ninguna función, ya sea incorporada o incluida en una biblioteca externa, que calcule cualquier tipo de números de Bernoulli o polinomios de Bernoulli.
  • Su respuesta debe proporcionar la salida correcta para todas las entradas hasta 60 inclusive.

Tabla de clasificación

El Fragmento de pila al final de esta publicación genera la tabla de clasificación a partir de las respuestas a) como una lista de la solución más corta por idioma yb) como una tabla de clasificación general.

Para asegurarse de que su respuesta se muestre, comience con un título, usando la siguiente plantilla de Markdown:

## Language Name, N bytes

¿Dónde Nestá el tamaño de su envío? Si mejora su puntaje, puede mantener los puntajes antiguos en el título, tachándolos. Por ejemplo:

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

Si desea incluir varios números en su encabezado (por ejemplo, porque su puntaje es la suma de dos archivos o desea enumerar las penalizaciones de la bandera del intérprete por separado), asegúrese de que el puntaje real sea el último número en el encabezado:

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

También puede hacer que el nombre del idioma sea un enlace que luego aparecerá en el fragmento:

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

Mostrar fragmento de código

code-golf  math  sequence  combinatorics 
— Mego
fuente
@MorganThrapp La implementación de referencia es solo para aclarar la definición de un número de Bernoulli, no para resolver realmente el problema.
— Mego
Ah, te tengo. Pensé que era una implementación completamente funcional.
— Morgan Thrapp
2
@Mego Ningún flotador estándar (ni siquiera precisión cuádruple) puede almacenar B_60 a precisión cuádruple. ¿Deberíamos usar un formato de precisión extendido si enviamos como decimales?
— lirtosiast
8
No me gusta el requisito de precisión. Algunos idiomas no tienen las herramientas para trabajar con flotadores con la precisión suficiente para B_60, y prefiero no lidiar con estos problemas cuando se juega un problema matemático. Es frustrante escribir una solución y luego descubrir que no es válida debido a lo que parece un tecnicismo.
— xnor
2
@xnor 6 dígitos de precisión ya parece increíblemente laxa.
— primo

Respuestas:

9

Julia, 58 bytes

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

Esto crea una función recursiva Bque acepta un número entero y devuelve un BigFloat(es decir, punto flotante de alta precisión).

Sin golf:

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

Minkolang 0.14 , 97 bytes

De hecho, intenté hacerlo de forma recursiva primero, pero mi intérprete, como está diseñado actualmente, en realidad no puede hacerlo. Si intenta recurrir desde un bucle for, comienza una nueva recursión. Así que opté por el enfoque de tabulación ... que tenía problemas de precisión. Así que hice todo con fracciones. Sin soporte incorporado para fracciones. [ suspiro ]

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

Pruébalo aquíBonificación: ¡la matriz tiene todas las fracciones para cada número de Bernoulli anterior!

Explicación (en un momento)

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

La tercera línea es responsable de 1/2si mes 1 y 0/1si mes un número impar mayor que 1. La segunda línea calcula B_mcon la fórmula de suma dada en la pregunta, y lo hace completamente con numeradores y denominadores. De lo contrario, sería mucho más corto. La primera mitad de la primera línea hace un poco de contabilidad y elige si ejecutar la segunda o tercera línea, y la segunda mitad divide el numerador y el denominador por su MCD (si corresponde) y almacena esos valores. Y genera la respuesta al final.

— El'endia Starman
fuente
8

Python 2, 118 bytes

Guardado 6 bytes debido a xsot .
Salvó 6 10 más debido a 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]

Utiliza la siguiente identidad:

donde A n es el enésimo número alternativo , que se puede definir formalmente como el número de permutaciones alternas en un conjunto de tamaño n , reducido a la mitad (ver también: A000111 ).

El algoritmo utilizado fue dado originalmente por Knuth y Buckholtz (1967) :

Deje T 1, k = 1 para todo k = 1..n

Los valores posteriores de T están dados por la relación de recurrencia:

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

A n es entonces dada por T n, 1

(ver también: A185414 )

Python 2, 152 bytes

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

Imprime la representación fraccionaria exacta, necesaria para valores superiores a 200 aproximadamente.

— primo
fuente
1
Si cambias range(2,n)a range(n-2)puedes acortar n-k+1a n+~k. Además, ¿hay alguna razón para usar en >>1lugar de /2? Por último, una mejora trivial, pero puede guardar algunos bytes aliasing range.
— xsot
Gracias por las sugerencias Al principio tuve dos expresiones, cuando me uní a ellos pasé por alto el cambio >>1con /2.
— primo
1
Hay un ahorro de un caracter en la línea de salida: print+(n<1)or-(-1.)**(n+n/2)*n/(4**n-2**n)*a[n%2^1%n]. Y el cálculo se puede hacer para el mismo recuento de caracteres quea=[1]*(n+1);exec"a=[(a[j-1]+a[j+1])*j/2for j in range(len(a)-1)];"*(n-1)
— Peter Taylor
@PeterTaylor el n+n/2es inteligente; 1 no necesita ser señalado, porque todos los demás valores impares son cero de todos modos. El cálculo alternativo es en realidad 4 bytes más corto con inversiones de bits, pero también considerablemente más lento, por alguna razón.
— primo
1
Estaba trabajando desde la tabla OEIS, y pensé que había encontrado rangey omitir una iteración para ser una forma inteligente de acortar la inicialización. La forma en que ahora ha dividido a cabo índices pares e impares es muy agradable, y permite un ahorro adicional tirando de la señal en la definición de a: a=[(-1)**(n/2),n<2]*n. Entonces el valor de retorno es +(n<1)or-n/(2.**n-4**n)*a[1]. También tienes un punto y coma al final de la línea 2.
— Peter Taylor
6

PARI / GP, 52 23 bytes

Usando la famosa fórmula n * ζ (1− n ) = - B n , donde ζ es la función Riemann Zeta .

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

Solución original, 52 bytes, utilizando la función de generación de números de Bernoulli .

n->n!*polcoeff(-x/sum(i=1,n+1,(-x)^i/i!)+O(x^n*x),n)
— alephalpha
fuente
Solo puede votar una vez. Sin embargo, es una pena que no sea exacto.
— primo
Según la documentación, la zetafunción se calcula utilizando números de Bernoulli, de hecho.
— primo
@primo, sí, considero todas las respuestas que usan zeta incorporado como trampa.
— Peter Taylor
Aún más fácil, bernfracy bernrealson 8 bytes cada uno y ya son funciones, por lo que no es necesario n->. Pero +1 para una buena solución.
— Charles
6

Python 3, 112 bytes

Editar: limpié esta respuesta. Si desea ver todas las otras formas en que pensé para responder esta pregunta en Python 2 y 3, mire las revisiones.

Si no uso la tabla de búsqueda (y uso la memorización en su lugar), ¡me las arreglo para obtener la definición recursiva a 112 bytes! ¡CORTEJAR! Tenga en cuenta que b(m)devuelve a Fraction. Como de costumbre, el conteo de bytes y un enlace para la prueba .

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

Y una función que usa una tabla de búsqueda y devuelve toda la tabla de fracciones de b(0)a b(m), inclusive.

from fractions import*
def b(m,r=[]):
 s=k=0;p=1
 while k<m:
  if k>=len(r):r=b(k,r)
  a=m-k;s+=Fraction(p*r[k])/-~a;p=p*a//-~k;k+=1
 return r+[1-s]
— Sherlock9
fuente
1
Creo que puede omitir el cero final en literales flotantes, por ejemplo, en 1.lugar de 1.0.
— Alex A.
@AlexA. Hecho. Eliminado .0por scompleto, porque se convertirá rápidamente en un flotador más tarde.
— Sherlock9
¿Se puede usar en p=v=1;exec('[...];p+=1'*k)lugar de su bucle más interno?
— lirtosiast
5

CJam, 69 49 34 33 bytes

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

Demostración en línea

Gracias a Cabbie407 , cuya respuesta me hizo conocer el algoritmo Akiyama-Tanigawa.

Disección

{           e# Function: takes n on the stack
  _),:)     e# Stack: n [1 2 3 ... n+1]
  :R        e# Store that array in R
  _:*       e# Stack: n [1 2 3 ... n+1] (n+1)!
  _@f/      e# Stack: n (n+1)! [(n+1)!/1 (n+1)!/2 (n+1)!/3 ... (n+1)!/(n+1)]
            e#   representing [1/1 1/2 ... 1/(n+1)] but avoiding floating point
  @{        e# Repeat n times:
    _(;.-   e#   Take pairwise differences
    R.*     e#   Pointwise multiply by 1-based indices
  }*        e#   Note that the tail of the array accumulates junk, but we don't care
  0=\d/     e# Take the first element and divide by (n+1)!
}
— Peter Taylor
fuente
Multiplicando por n! Para evitar la pérdida de precisión es inteligente, si no un poco ridículo. Me pregunto si el algoritmo no podría ser refactorizado ligeramente para evitar esto.
— primo
No creo que la refactorización pueda evitar la necesidad de escalar por la sencilla razón de que, dado que sabemos que cualquier otro número de Bernoulli es 0, obviamente hay mucha resta de valores similares, por lo que hay muchos lugares donde la pérdida de importancia catastrófica puede ocurrir.
— Peter Taylor
4

PARI / GP, 45 bytes

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

Usando la misma fórmula que mi respuesta de Python , con A n generada a través de polylog.

Script de prueba

Ejecute gp, en el indicador, pegue lo siguiente:

n->if(n,2*n/(2^n-4^n)*real(polylog(1-n,I)),1)
for(i=0, 60, print(i, ": ", %(i)))
— primo
fuente
1
Gracias por proporcionar un script de prueba, ¡hizo que probarlo fuera mucho más fácil!
— Mego
@Mego para ti y para mí;)
— primo
4

Mathematica, 52 48 42 bytes

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

Función sin nombre que utiliza la definición literal.

— LegionMammal978
fuente
Es lo Sign@#necesario?
— alephalpha
Lo probé en mi computadora. Después de eliminar el Sign@#, aún devuelve la respuesta correcta para 0.
— alephalpha
3

Python 2, 132 130 bytes

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

Esta es solo una versión de golf de la implementación de referencia.

Esto es un poco lento en la práctica, pero se puede acelerar significativamente con la memorización:

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

Puede probar esta versión en línea en Ideone .

— Dennis
fuente
3

gawk4, 79 bytes

Código de 77 bytes + 2 bytes para -Mbandera

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

Es una implementación del algoritmo Akiyama-Tanigawa de la página de Wikipedia.

Tuve algunos problemas con la "regla de los 6 dígitos decimales", porque imprime el número entero y luego los 6 dígitos, pero no hay una lista aquí para comparar los resultados.

Un defecto es que esto imprime un signo menos delante de 0.000000muchas veces, pero no creo que eso esté mal.

Ejemplo de uso

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

Salida de 0 a 60

0 -> 1.000000
1 -> 0.500000
2 -> 0.166667
3 -> -0.000000
4 -> -0.033333
5 -> 0.000000
6 -> 0.023810
7 -> 0.000000
8 -> -0.033333
9 -> 0.000000
10 -> 0.075758
11 -> -0.000000
12 -> -0.253114
13 -> -0.000000
14 -> 1.166667
15 -> -0.000000
16 -> -7.092157
17 -> -0.000000
18 -> 54.971178
19 -> -0.000000
20 -> -529.124242
21 -> -0.000000
22 -> 6192.123188
23 -> 0.000000
24 -> -86580.253114
25 -> 0.000000
26 -> 1425517.166667
27 -> 0.000000
28 -> -27298231.067816
29 -> 0.000000
30 -> 601580873.900642
31 -> 0.000000
32 -> -15116315767.092157
33 -> 0.000000
34 -> 429614643061.166667
35 -> 0.000000
36 -> -13711655205088.332772
37 -> 0.000000
38 -> 488332318973593.166667
39 -> -0.000000
40 -> -19296579341940068.148633
41 -> -0.000000
42 -> 841693047573682615.000554
43 -> -0.000000
44 -> -40338071854059455413.076812
45 -> -0.000000
46 -> 2115074863808199160560.145390
47 -> -0.000000
48 -> -120866265222965259346027.311937
49 -> -0.000000
50 -> 7500866746076964366855720.075758
51 -> -0.000000
52 -> -503877810148106891413789303.052201
53 -> -0.000000
54 -> 36528776484818123335110430842.971178
55 -> -0.000000
56 -> -2849876930245088222626914643291.067816
57 -> -0.000000
58 -> 238654274996836276446459819192192.149718
59 -> -0.000000
60 -> -21399949257225333665810744765191097.392674
— Cabbie407
fuente
Funcionaria printf"%e"?
— primo
No, no lo sería, porque los 0.00000s son muy pequeños y no son realmente cero.
— Cabbie407
2

GolfScript, 63 bytes

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

Demo en línea .

Usando la misma fórmula que mi respuesta de Python .

Script de prueba

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

El enlace apphb terminará con esto. Si no tiene GolfScript instalado localmente, le recomiendo usar el intérprete de golf anarchy (use el formulario, seleccione GolfScript, pegue, envíe).

— primo
fuente
2

Perl, 101 bytes

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

Contando el shebang como tres, la entrada se toma de stdin.

Usando la misma fórmula que mi respuesta de Python .

Uso de muestra

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

Demo en línea .

— primo
fuente
2

R, 93 bytes

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

No es realmente original como solución. Si hay algún comentario, ¡no dudes en hacerlo!

Sin golf:

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

1-sum(v)
— Frédéric
fuente
Sé que esto es un poco tarde ahora, pero puede guardar 3 bytes cambiando el orden de la instrucción if/ elsey usarlo m>0, así como hacer un bucle 1:m-1.
— Billywob
2

En realidad , 46 45 bytes (no competitivos)

He tenido la intención de hacer una respuesta en serio / en realidad durante meses y ahora puedo. Como esto usa comandos que Seriously no tenía en noviembre de 2015, no compite. Sugerencias de golf bienvenidas. Pruébalo en línea!

Editar: en febrero de 2017, hubo una actualización de En realidad que cambió qué funciones literales son cuáles. Normalmente, esto simplemente no competiría para ningún desafío escrito antes de febrero, pero como esta respuesta ya no es competitiva, edité esta respuesta de todos modos. Disfrutar.

Esto utiliza la definición explícita de los números de Bernoulli en 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).
— Sherlock9
fuente
2
Utiliza comandos ¿En serio no tenía en noviembre de 2015? ¡Hombre, esto usa un lenguaje completamente nuevo que no existía en noviembre de 2015! Estoy muy orgulloso ...
— Mego
1

Ruby, 66 61 bytes

Esta es una versión Ruby de mi respuesta de Python.

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

Como esto se usa Rationalen sus respuestas, estoy bastante seguro de que funciona hasta 60, pero tuve problemas para ejecutar incluso b[24], así que implementé la tabla de búsqueda nuevamente para 86 81 80 bytes.

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

J, 10 bytes

(%1-^@-)t:

Calcula el n º número Bernoulli mediante la búsqueda de la n º coeficiente de la función de generación exponencial de x / (1 - e -x ).

Uso

Si a la entrada se le da un número entero o flota como argumento, generará un flotante. Si se le da un entero extendido, marcado con un sufijo x, generará un entero extendido o un racional, dos enteros extendidos separados por 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

Explicación

(%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)
— millas
fuente
1

Axioma, 134 147 bytes

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

ungolf y prueba

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

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

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

APL (NARS), 83 caracteres, 166 bytes

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]

Entrada como salida entera como gran racional

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

Haskell, 95 bytes

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

Esto implementa la definición explícita de los números de Bernoulli descritos en la página de Wikipedia .

— Sherlock9
fuente
0

Perl 6, 83 bytes

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

Una solución más rápida de 114 bytes:

my @b=1;for 1..+slurp() {@b.push: 1-[+] (^$^m).map: {([*] $m+1-$_..$m)*@b[$_]/($m+1-$_)/([*] 1..$_)}};say @b[*-1];
— bb94
fuente
Su código para un desafío de código de golf debe ser lo más corto posible, incluso si se necesitan algunas vidas del universo para terminar con ciertas entradas.
— Mego
0

Javascript, 168 bytes

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

Establezca la variable 'k' en el número de Bernoulli que desee, y el resultado es c [0] sobre un [0]. (numerador denominador)

Uso de muestra

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

No es tan pequeño como los otros, pero el único que he escrito que se acerca. Vea https://marquisdegeek.com/code_ada99 para mis otros intentos (que no sean de golf).

— Marqués de Geek
fuente
0

Axioma, 57 bytes

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

código para prueba y resultados

(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

hay que tener en cuenta que la función no es la que alguien escribió anteriormente, sino t*%e^t/(%e^t-1))con% e Euler costant

— RosLuP
fuente
0

Pyth , 22 bytes

L?b-1sm*.cbdcyd-btdUb1

Pruébalo en línea!

Define una función que se llama como y<number>, por ejemplo yQ.

L                      # y=lambda b:
 ?b                  1 # ... if b else 1
   -1                  # 1 -
     s                 #     sum(
      m            Ub  #         map(lambda d: ... , range(b)) 
       *.cbd           #           combinations(b, d) *
            cyd        #             y(d) /      (float division)
               -btd    #                    b - (d - 1)
— ar4093
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.