La costante di Khinchin è una curiosa costante matematica che, secondo Wolfram MathWold , è "notoriamente difficile da calcolare con alta precisione" .

Eccolo a 100 cifre:

2,685452001065306445309714835481795693820382293994462953051152345557218859537152002801141174931847697 ...

Scrivi un programma in 64 byte o meno che restituisca la costante di Khinchin al numero massimo di posizioni decimali corrette.

• Non è possibile utilizzare costanti di libreria incorporate o funzioni direttamente correlate alla costante di Khinchin. (ad esempio Math.Khinchin (precisione) non è assolutamente consentito.)
• È possibile utilizzare le librerie matematiche per calcolare logaritmi, somme, ecc.
• È possibile codificare in tutto o in parte la risposta.
• Il programma deve produrre un output finito ed essere eseguito in meno di un'ora su un computer ragionevolmente moderno (come quelli elencati qui ).
• È necessario eseguire l'output su stdout. Non ci sono input.
• È possibile utilizzare qualsiasi carattere desiderato purché http://mothereff.in/byte-counter registri 64 byte o meno.

punteggio

Il tuo punteggio è il numero di cifre successive nella costante di Khinchin che il tuo programma emette correttamente, a partire da 2,68 ... Puoi generare cifre errate ma solo l'ultima cifra corretta viene conteggiata per il tuo punteggio.

Ad esempio, un output di

2.68545200 2 06530644530971483548179569382038229399446295305115234555721

segnerebbe 9 punti. Uno per ciascuna delle cifre 2 6 8 5 4 5 2 0 0ma niente dopo il 2 che dovrebbe essere un 1.

Acero, 200+

Il seguente comando Maple calcola la costante di Khinchin con la precisione richiesta (qui, 200 cifre):

evalf[200](exp(sum((-1)^k*(2-2^k)*ζ(1,k)/k,k=2..∞)/ln(2)));

Questo codice dovrebbe funzionare se lo copi e lo incolli nell'interfaccia grafica di Maple. Il ζprende due byte in UTF-8 e i ∞tre, per un totale di 62 byte.

Scrivere le versioni ASCII di quei simboli, anche con il trucco di usare min()invece di infinity, ahimè, porta il conteggio dei byte fino a 66:

evalf[200](exp(sum((-1)^k*(2-2^k)*Zeta(1,k)/k,k=2..min())/ln(2)));

Il numero di cifre calcolate può essere facilmente modificato cambiando il numero tra parentesi quadre dopo evalf. Sul mio computer piuttosto vecchio, 200 cifre sembrano finire in circa mezz'ora; il tuo potrebbe essere in grado di fare di più. Si noti che Maple arrotonda il risultato alla precisione richiesta invece di troncarlo, quindi il numero effettivo di cifre corrispondenti potrebbe essere leggermente inferiore.

Questo metodo di calcolo della costante si basa sulla formula (9) dalla pagina MathWorld , citata lì a Gosper (1996, comm. Pers.):

Questo è stato il metodo più efficiente che sono riuscito a comprimere (a malapena) in 64 byte o meno.

CJam - 118

2'."*;TeT?_aN{.i9B*ZEay
G`9~eW}nE=Lr-`B}    )D>9m9"136b

Provalo su http://cjam.aditsu.net/

Poiché stackexchange distrugge alcuni dei personaggi, ecco un programma che genera il programma sopra; eseguilo prima, quindi esegui il suo output:

"2'.\""685452001065306445309714835481795693820382293994462953051152345557218859537152002801141174931847697995153465905288090 136b:c"\"136b"

Spiegazione:

2push 2
'.push il punto
"…"è una stringa contenente il resto delle cifre in forma codificata
128bconverte la stringa in un numero, trattando i caratteri come cifre nella base 128 (tramite il loro codice ASCII)

Kona 63

Risposta semplice codificata:

2.68545200106530644530971483548179569382038229399446295305115234

Haskell, 5

Bene, dal momento che nessuno ha pubblicato una soluzione usando la matematica reale, ho deciso di farlo, anche se non è vicino come le altre risposte.

main=print$product[(1+1/r/(r+2))**2`logBase`r|r<-[1..99999999]]

Questo calcola 2.6854453689859192, che è un enorme 5 caratteri della costante. Wolfram aveva ragione quando dicevano che era "difficile calcolare con alta precisione".

Mathematica, 6

(Times@@Rest@ContinuedFraction[Pi,977])^(1.`9/976)

dà

2.68545843

e utilizza solo 50 byte, quindi c'è spazio per trovare qualcosa di meglio Pie utilizzare una frazione continua maggiore, ma non sono sicuro che migliorerà molto con un tempo di esecuzione di un'ora. (Soprattutto perché trovare una combinazione migliore richiederebbe probabilmente diversi giorni se sto usando solo la forza bruta.)

(Certo, sei stato abbastanza intelligente da non consentire Khinchin~N~2000, dove 2000potresti essere sostituito con qualsiasi numero che ti dia un risultato entro un'ora;).

wxMaxima 3

Un metodo effettivamente calcolato!

bfloat(product((1+1/(n*(n+2)))^(log(n)/log(2)),n,1,10000));

Dopo circa 25 minuti, è tornato

2.681499686663101b0

Ora capisco perché la pagina Mathematica lo affermasse. Ho 6 personaggi con cui giocare, ma non riesco a immaginare che l'aggiunta di 6 0 sarebbe (a) eseguita in <60 min e (b) mi darebbe una soluzione più accurata.

GNU BC , 5 cifre (programma 54 byte)

Un tentativo di calcolare effettivamente. GNU BC è orribilmente lento. Ciò ha funzionato per 53 minuti su una VM Ubuntu 14.04 in esecuzione su un MacBook Pro Retina di metà 2012. Stranamente funziona più velocemente nella VM rispetto al bare metal OSX - presumibilmente la versione GNU è meglio ottimizzata per questa attività rispetto alla versione BSD.

for(k=r=1;r++<10^7;)k*=e(l(1/(r*(r+2))+1)*l(r)/l(2))
k

Produzione:

2.68544536902156538295

Nota:

bc -ldeve essere usato per e()e l()funzioni (e impostazione scala = 20).

Calcolo in virgola mobile di CJam - 6

1e8{I{1.II2+*/)I2mL#*}1.?}fI

Si adatta ai 32 byte originali :)

Funzionando con l'interprete java usando java 8, lo emette dopo circa un minuto sul mio laptop:

2.6854513126595827

L'interprete online probabilmente impiegherebbe troppo tempo.

Python, 64 66

print"2.%i"%int('anljsgqif7gwwwsrntcz7zv2obv6gv5us7fzfwjcaj',36)

Uscite:

2.68545200106530644530971483548179569382038229399446295305115234555

Rubino - 73

Sfortunatamente, puoi solo convertire fino alla base 36 usando to_iin Ruby:

"2.#{"hmegxpkvliy1vaw4lb054ep8wsqwkz2yx9cm9jvc9yfd48j".to_i 36}"

che ritorna

"2.6854520010653064453097148354817956938203822939944629530511523455572188595"

RPL / 2, 7 cifre calcolate, 61 byte

'LN(FLOOR(1/X))/(X+1)/LN(2)' { 'X' 1e-9 1 } 1e-7 INT DROP EXP

restituisce 2.68545210493822 in un minuto sul mio vecchio laptop (Intel Core2).

Nessuna funzione Zeta in RPL / 2, per quanto ne so, è per questo che ho usato l'integrazione (formula 15 dalla pagina di Mathworld). In linea di principio l'accuratezza potrebbe essere migliorata sostituendo 1e-9 e 1e-7 con un numero inferiore, ma a quanto pare mi mancava la memoria.

Ovviamente il ricorso all'infinito prodotto risolve questo punto, sembra

1 1 1e9 FOR I 1 1 I dup 2 + * / + I LN 2 LN / ^ * NEXT

e funzionerà come su un calcolo HP RPL, ma risulta essere di due ordini di grandezza più lento (sul portatile, non ho provato sul mio HP!) e fornisce solo 6 cifre.

Quindi l'algoritmo di integrazione in RPL / 2 fa davvero un buon lavoro.

Molte lingue sostitutive, 61

scusa, non ho trovato una soluzione migliore.

"2.685452001065306445309714835481795693820382293994462953051152"

Le regole non dicono che la sequenza numerica corretta non possa essere preceduta da virgolette, quindi sto usando questo. Eseguendolo ad esempio in una console JS, otterrai la stessa stringa, comprese le virgolette.

Python (5)

x=3**.1
p=1
for _ in[1]*10**6:p*=(x//1)**1e-6;x=1/(x%1)
print(p)

Output: 2.6854396408091694

(L'uscita richiede ~ 2 secondi.)

In solidarietà con le altre soluzioni matematiche, ne fornirò una ancora peggio convergente che calcola la media geometrica del primo milione di coefficienti di frazione continua di un singolo numero irrazionale arbitrario che non è di un tipo noto per non funzionare. In realtà, ho truccato quel numero provandone alcuni finché non ne ho ottenuto uno che coincidesse con una cifra aggiuntiva.

Cosa divertente: ho congelato il mio computer e ho dovuto fare un arresto intenso dopo aver cercato di abbreviare questo codice con il trucco da golf di Python for _ in[1]*10**6:codecon cui sostituirlo exec("code"*10**6).

ES7, 56

alert`2.6854520010653064453097148354817956938203822939944629531`