La costante di Khinchin al maggior numero di decimali possibile in 64 byte o meno


22

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.


2
Perché stai permettendo la codifica completa dell'intera risposta?
William Barbosa,

5
@WilliamBarbosa perché no? idealmente dovrebbe esserci una soluzione con un punteggio migliore di 31. In caso contrario, beh, è ​​un peccato.
Martin Ender,

1
L'unicode è permesso? Come contarlo?
aditsu,

3
Dovresti consentire 64b invece di 32 e contare tutti i caratteri come UTF-8 byte ( mothereff.in/byte-counter ) (= da 1 a 4 byte per carattere a seconda del piano Unicode). Inoltre, le soluzioni esistenti potrebbero essere facilmente adattate a 64b
xem

3
@PeterTaylor Ho codificato una soluzione in virgola mobile di CJam, e lascia che te lo dica, la precisione limitata non è il problema principale: p
aditsu,

Risposte:


11

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

            Equazione

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


Piuttosto pulito. Se solo avessi avuto Maple: /
Calvin's Hobbies il

12

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)


2
Molto bella. Puoi spiegarlo un po '?
Kyle Kanos,

@KyleKanos ha aggiunto una spiegazione
aditsu, il

È fantastico Dovrei imparare CJam un giorno ... Inoltre, non riesco a far funzionare il tuo interprete online nel browser Opera, sebbene funzioni sul mio Firefox. Probabilmente un problema di Opera, ma ho pensato di menzionarlo.
Kyle Kanos,

1
@ Calvin'sHobbies Nel 1997 Xavier Gourdon calcolò le prime 110.000 cifre in 22 ore utilizzando al massimo un processore da 250 MHz. Quindi potresti essere in grado di calcolare 1000 volte più cifre di questa soluzione in un'ora. web.archive.org/web/20120218093629/http://pi.lacim.uqam.ca/…
Alex L

1
@ Calvin'sHobbies vede questo link per un programma completo che secondo come riferito ha calcolato 2000 cifre in 7 secondi.
aditsu,

5

Kona 63

Risposta semplice codificata:

2.68545200106530644530971483548179569382038229399446295305115234

mmm non è 63?
XX

@xem: errore tipografico minore. Fisso. : D
Kyle Kanos,

1
Funziona anche in GNU BC
Digital Trauma,

@DigitalTrauma: Probabilmente funziona anche in molte altre lingue, mi sono appena bloccato con Kona perché ho già risposto prima.
Kyle Kanos,

5

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".


Programma da 63 byte - 1 byte da risparmiare! Bello!
Digital Trauma,

Il byte extra potrebbe essere un altro 9, ma il mio computer non è in grado di gestirlo e, anche se potesse, non sono sicuro che si tradurrebbe in un'altra cifra accurata.
Zaq,

Usando Ruby, ho praticamente raggiunto il massimo che si potesse fare usando questa formula, eseguendo questa operazione in 60 secondi. Ho ottenuto 2.685451312659854: tio.run/##KypNqvz/P9vWkEvDUE/…
Simply Beautiful Art,

3

Mathematica, 6

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

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


1
+1 per usare il significato della costante, non solo una formula.
Vi.

2

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.


Sospetto: ogni zero aggiuntivo aggiunge meno di un'altra cifra corretta: '(
Simply Beautiful Art,

1

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


1

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.


1

Python, 64 66

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

Uscite:

2.68545200106530644530971483548179569382038229399446295305115234555

Puoi tagliare lo spazio dopo il printper spremere un altro personaggio.
xnor

1

Rubino - 73

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

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

che ritorna

"2.6854520010653064453097148354817956938203822939944629530511523455572188595"

1

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.


0

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.


1
Sì, questo vale anche con una citazione davanti. Importa solo che il 2.685 ... è ininterrotto.
Calvin's Hobbies,

0

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


0

ES7, 56

alert`2.6854520010653064453097148354817956938203822939944629531`
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.