Numeri di Bernoulli

23

I numeri di Bernoulli (in particolare, il secondo numero di Bernoulli) sono definiti dalla seguente definizione ricorsiva:

secondi numeri di Bernoulli

Dove MCKindica una combinazione .

Dato un intero non negativo mcome input, genera la rappresentazione decimale OPPURE una frazione ridotta per il msecondo numero di Bernoulli. Se si genera una rappresentazione decimale, è necessario disporre di almeno 6 cifre decimali (cifre dopo la virgola) di precisione e deve essere accurata quando arrotondata a 6 cifre decimali. Ad esempio, per m = 2, 0.166666523è accettabile perché arrotondato a 0.166667. 0.166666389non è accettabile, perché arrotondato a 0.166666. Gli zero finali possono essere omessi. La notazione scientifica può essere utilizzata per le rappresentazioni decimali.

Ecco l'input e l'output previsto per un mmassimo di 60 inclusi, in notazione scientifica arrotondata al 6 ° decimale e come frazioni ridotte:

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)

Implementazione di riferimento (in 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

Regole

  • Questo è code-golf , quindi vince il codice più breve in byte
  • Non è possibile utilizzare alcuna funzione, integrata o inclusa in una libreria esterna, che calcoli né il tipo di numeri di Bernoulli né i polinomi di Bernoulli.
  • La risposta deve fornire un output corretto per tutti gli input fino a 60 inclusi.

Classifica

Lo snippet di stack nella parte inferiore di questo post genera la classifica dalle risposte a) come un elenco della soluzione più breve per lingua eb) come classifica generale.

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, usando il seguente modello Markdown:

## Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

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

Se si desidera includere più numeri nell'intestazione (ad es. Perché il punteggio è la somma di due file o si desidera elencare separatamente le penalità del flag dell'interprete), assicurarsi che il punteggio effettivo sia l' ultimo numero nell'intestazione:

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

Puoi anche rendere il nome della lingua un collegamento che verrà quindi visualizzato nello snippet:

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

Mostra snippet di codice

code-golf  math  sequence  combinatorics 
— Mego
fonte
@MorganThrapp L'implementazione di riferimento è solo per rendere più chiara la definizione di un numero di Bernoulli, non per risolvere effettivamente il problema.
— Mego
Ah, capito. Ho pensato che fosse un'implementazione pienamente funzionale.
— Morgan Thrapp,
2
@Mego Nessun float standard (nemmeno la precisione quad) può memorizzare la precisione da B_60 a quad. Dovremmo quindi utilizzare un formato di precisione esteso se produciamo decimali?
— lirtosiast
8
Non mi piace il requisito di precisione. Alcune lingue non hanno gli strumenti per lavorare con float con una precisione sufficiente per B_60, e preferirei non affrontare tali problemi quando si gioca a golf un problema matematico. È frustrante scrivere una soluzione e poi scoprire che non è valido a causa di quello che sembra un tecnicismo.
— xnor
2
@xnor 6 cifre di precisione sembrano già incredibilmente rilassate.
— primo

Risposte:

8

Julia, 23 20 byte

Salvato 3 byte grazie ad Alex A.

Utilizza la stessa formula della mia soluzione Mathematica e della soluzione PARI / GP .

n->n>0?-zeta(1-n)n:1
— alephalpha
fonte
2
20 byte:n->n>0?-zeta(1-n)n:1
— Alex A.
@AlexA. Non so perché, ma zeta(n)genera un errore quando nè un numero intero negativo. Sto usando Julia 0.2.1 su Linux.
— alephalpha,
1
Oh mio Dio, la tua versione di Julia è abbastanza obsoleta. Funziona bene per me su 0.4.1.
— Alex A.
9

Julia, 58 byte

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

Questo crea una funzione ricorsiva Bche accetta un numero intero e restituisce un BigFloat(ovvero un punto mobile ad alta precisione).

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
— Alex A.
fonte
9

Minkolang 0,14 , 97 byte

In realtà ho provato a farlo prima in modo ricorsivo, ma il mio interprete, come attualmente progettato, in realtà non può farlo. Se si tenta di ricorrere all'interno di un ciclo for, inizia una nuova ricorsione. Così ho optato per l'approccio tabulato ... che aveva problemi di precisione. Quindi ho fatto tutto con le frazioni. Senza supporto integrato per le frazioni. [ sospiro ]

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

Provalo qui. Bonus: l'array ha tutte le frazioni per ogni precedente numero di Bernoulli!

Spiegazione (tra poco)

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 terza riga è responsabile per 1/2if mè 1 e 0/1if mè un numero dispari maggiore di 1. La seconda riga calcola B_mcon la formula di somma fornita nella domanda e lo fa interamente con numeratori e denominatori. Altrimenti sarebbe molto più breve. La prima metà della prima riga fa un po 'di contabilità e sceglie se eseguire la seconda o la terza riga, e la seconda metà divide il numeratore e il denominatore per il loro GCD (se applicabile) e memorizza tali valori. E genera la risposta alla fine.

— El'endia Starman
fonte
8

Python 2, 118 byte

6 byte salvati grazie a xsot .
Ne ho salvati altri 6 10 grazie 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]

Utilizza la seguente identità:

dove A n è il n ° alternata numero , che può essere formalmente definito come il numero di permutazione alternata su un insieme di dimensione n , dimezzato (vedi anche: A000111 ).

L'algoritmo utilizzato è stato originariamente fornito da Knuth e Buckholtz (1967) :

Sia T 1, k = 1 per tutti k = 1..n

I valori successivi di T sono dati dalla relazione di ricorrenza:

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

A n è quindi dato da T n, 1

(vedi anche: A185414 )

Python 2, 152 byte

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

Stampa l'esatta rappresentazione frazionaria, necessaria per valori superiori a circa 200.

— Primo
fonte
1
Se si cambia range(2,n)per range(n-2)è possibile abbreviare n-k+1a n+~k. Inoltre, c'è un motivo che usi al >>1posto di /2? Infine, un banale miglioramento, ma è possibile salvare alcuni byte con l'aliasing range.
— xsot,
Grazie per i suggerimenti Inizialmente avevo due espressioni, quando mi unii a loro ho trascurato cambiare >>1con /2.
— primo
1
C'è un risparmio di un carattere nella linea di uscita: print+(n<1)or-(-1.)**(n+n/2)*n/(4**n-2**n)*a[n%2^1%n]. E il calcolo può essere fatto per lo stesso conteggio dei caratteri dia=[1]*(n+1);exec"a=[(a[j-1]+a[j+1])*j/2for j in range(len(a)-1)];"*(n-1)
— Peter Taylor,
@PeterTaylor the n+n/2è intelligente; 1 non ha bisogno di essere individuato, perché tutti gli altri valori dispari sono comunque zero. Il calcolo alternativo è in realtà di 4 byte più corto con inversioni di bit, ma anche molto più lento, per qualche motivo.
— primo
1
Stavo lavorando dal tavolo OEIS e pensavo che avessi trovato rangee saltando un'iterazione per essere un modo intelligente per abbreviare l'inizializzazione. Il modo in cui hai ora Split out pari e dispari indici è molto bello, e permette un ulteriore risparmio tirando il segno nella definizione di a: a=[(-1)**(n/2),n<2]*n. Quindi il valore restituito è +(n<1)or-n/(2.**n-4**n)*a[1]. Hai anche un punto e virgola randagio alla fine della riga 2.
— Peter Taylor,
6

PARI / GP, 52 23 byte

Usando la famosa formula n * ζ (1− n ) = - B n , dove ζ è la funzione di Riemann Zeta .

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

Soluzione originale, 52 byte, utilizzando la funzione generatrice dei numeri di Bernoulli .

n->n!*polcoeff(-x/sum(i=1,n+1,(-x)^i/i!)+O(x^n*x),n)
— alephalpha
fonte
Può votare una sola volta. È un peccato, non è esatto, però.
— primo
Secondo la documentazione, infatti, la zetafunzione viene calcolata utilizzando i numeri di Bernoulli.
— primo
@primo, sì, considero tutte le risposte che usano la zeta integrata come imbrogli.
— Peter Taylor,
Ancora più facile, bernfrace bernrealsono 8 byte ciascuno e sono già le funzioni, quindi non è necessario per il n->. Ma +1 per una buona soluzione.
— Charles,
6

Python 3, 112 byte

Modifica: ho ripulito questa risposta. Se vuoi vedere tutti gli altri modi in cui ho pensato di rispondere a questa domanda in Python 2 e 3, guarda le revisioni.

Se non uso la tabella di ricerca (e invece utilizzo la memoization), riesco a ottenere la definizione ricorsiva a 112 byte! CORTEGGIARE! Si noti che b(m)restituisce a Fraction. Come al solito, il conteggio dei byte e un collegamento per il test .

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

E una funzione che utilizza una tabella di ricerca e restituisce l'intera tabella delle frazioni da b(0)a b(m), incluso.

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
fonte
1
Penso che tu possa omettere lo zero finale sui letterali float, ad es. 1.Invece di 1.0.
— Alex A.
@AlexA. Fatto. Rimosso .0da stutto, perché diventerà rapidamente un galleggiante in seguito.
— Sherlock9,
Puoi usare al p=v=1;exec('[...];p+=1'*k)posto del tuo ciclo più interno?
— lirtosiast,
5

CJam, 69 49 34 33 byte

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

Demo online

Grazie a Cabbie407 , la cui risposta mi ha fatto conoscere l'algoritmo Akiyama – Tanigawa.

Dissezione

{           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
fonte
Moltiplicando per n! prevenire la perdita di precisione è intelligente, se non leggermente ridicolo. Mi chiedo se l'algoritmo non possa essere leggermente modificato per evitare questo.
— primo
Non penso che il refactoring possa evitare la necessità di ridimensionare per la semplice ragione che poiché sappiamo che ogni altro numero di Bernoulli è 0 c'è ovviamente molta sottrazione di valori simili in corso, quindi ci sono molti posti in cui una catastrofica perdita di significato può succedere.
— Peter Taylor,
4

PARI / GP, 45 byte

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

Usando la stessa formula della mia risposta Python , con A n generato tramite polilogo.

Test script

Esegui gp, al prompt incollare quanto segue:

n->if(n,2*n/(2^n-4^n)*real(polylog(1-n,I)),1)
for(i=0, 60, print(i, ": ", %(i)))
— Primo
fonte
1
Grazie per aver fornito uno script di test - ha reso il test molto più semplice!
— Mego
@Mego per entrambi e per me;)
— primo
4

Mathematica, 52 48 42 byte

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

Funzione senza nome che utilizza la definizione letterale.

— LegionMammal978
fonte
È Sign@#necessario?
— alephalpha,
L'ho provato sul mio computer. Dopo aver rimosso Sign@#, restituisce comunque la risposta corretta per 0.
— alephalpha,
3

Python 2, 132 130 byte

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

Questa è solo una versione golfizzata dell'implementazione di riferimento.

Questo è un po 'lento in pratica, ma può essere accelerato in modo significativo con la memoizzazione:

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

Puoi provare questa versione online su Ideone .

— Dennis
fonte
3

gawk4, 79 byte

Codice 77 byte + 2 byte per -Mflag

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

È un'implementazione dell'algoritmo Akiyama – Tanigawa dalla pagina di Wikipedia.

Si è verificato un problema con la "regola delle 6 cifre decimali", perché stampa l'intero numero e quindi le 6 cifre, ma qui non esiste un elenco per confrontare i risultati.

Un difetto è che questo stampa un segno meno di fronte a 0.000000molte volte, ma non penso che sia sbagliato.

Esempio di utilizzo

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

Uscita da 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
fonte
Funzionerebbe printf"%e"?
— primo
No, non lo sarebbe, perché le 0.00000s sono solo molto piccole e non proprio zero.
— Cabbie407,
2

GolfScript, 63 byte

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

Demo online .

Usando la stessa formula della mia risposta Python .

Test script

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

Il link apphb scadrà su questo. Se non hai installato GolfScript localmente, ti consiglio di usare l' interprete di golf dell'anarchia (usa il modulo, seleziona GolfScript, incolla, invia).

— Primo
fonte
2

Perl, 101 byte

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

Contando lo shebang come tre, l'input viene preso dallo stdin.

Usando la stessa formula della mia risposta Python .

Esempio di utilizzo

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

Demo online .

— Primo
fonte
2

R, 93 byte

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

Non proprio originale come soluzione. Se qualche commento, non esitate!

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)
— Frédéric
fonte
So che ora è un po 'in ritardo, ma è possibile salvare 3 byte modificando l' ordine delle istruzioni if/ elsee utilizzandoli m>0oltre a eseguire il ciclo 1:m-1.
— Billywob,
2

In realtà , 46 45 byte (non concorrenti)

Ho intenzione di fare una risposta seria / reale per mesi e ora posso. Poiché utilizza comandi che Seriamente non ha avuto nel novembre 2015, non è in competizione. Suggerimenti di golf benvenuti. Provalo online!

Modifica: nel febbraio del 2017, c'è stato un aggiornamento di Actually che ha cambiato le letterali di funzione quali. Normalmente, questo sarebbe semplicemente non competitivo per qualsiasi sfida scritta prima di febbraio, ma poiché questa risposta è già non competitiva, ho comunque modificato questa risposta. Godere.

Questo utilizza la definizione esplicita dei numeri di Bernoulli su 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
fonte
2
Usa i comandi Seriamente non ha avuto a novembre 2015? Amico, questo usa un linguaggio completamente nuovo che non esisteva a novembre 2015! Sono così orgoglioso ...
— Mego,
1

Rubino, 66 61 byte

Questa è una versione Ruby della mia risposta Python.

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

Dal momento che questo utilizza Rationalnelle sue risposte, sono abbastanza sicuro che funzioni fino a 60, ma ho avuto problemi anche con l'esecuzione b[24], quindi ho implementato nuovamente la tabella di ricerca per 86 81 80 byte.

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

J, 10 byte

(%1-^@-)t:

Calcola il n esimo numero di Bernoulli trovando il n esimo coefficiente della funzione generatrice esponenziale di x / (1 - e -x ).

uso

Se all'input viene fornito un numero intero o float come argomento, verrà generato un float. Se viene fornito un numero intero esteso, contrassegnato da un suffisso x, verrà generato un numero intero esteso o un numero intero esteso razionale, separati da 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

Spiegazione

(%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)
— miglia
fonte
1

Assioma, 134 147 byte

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

ungolf e prova

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

APL (NARS), 83 caratteri, 166 byte

r←B w;i
r←,1⋄i←0x⋄w+←1
→3×⍳w≤i+←1⋄r←r,1-+/{(1+i-⍵)÷⍨(⍵!i)×r[⍵+1]}¨0..i-1⋄→2
r←r[i]

Input come output intero come grande razionale

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

Haskell, 95 byte

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

Questo implementa la definizione esplicita dei numeri di Bernoulli delineati nella pagina di Wikipedia .

— Sherlock9
fonte
0

Perl 6, 83 byte

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

Una soluzione più veloce a 114 byte:

my @b=1;for 1..+slurp() {@b.push: 1-[+] (^$^m).map: {([*] $m+1-$_..$m)*@b[$_]/($m+1-$_)/([*] 1..$_)}};say @b[*-1];
— bb94
fonte
Il tuo codice per una sfida di golf del codice deve essere il più breve possibile, anche se ci vogliono alcune vite dell'universo per terminare determinati input.
— Mego,
0

Javascript, 168 byte

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

Imposta la variabile 'k' sul numero di Bernoulli desiderato e il risultato è c [0] su uno [0]. (numeratore denominatore)

Esempio di utilizzo

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

Non piccolo come gli altri, ma l'unico che ho scritto che si avvicina. Vedi https://marquisdegeek.com/code_ada99 per i miei altri tentativi (non di golf).

— Marchese de Geek
fonte
0

Assioma, 57 byte

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

codice per test e risultati

(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

bisogna notare che la funzione non è quella che qualcuno ha scritto sopra ma t*%e^t/(%e^t-1))con costanti% e Euler

— RosLuP
fonte
0

Pyth , 22 byte

L?b-1sm*.cbdcyd-btdUb1

Provalo online!

Definisce una funzione chiamata come y<number>, ad es 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
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.